1
// Code generated by 'go generate'; DO NOT EDIT.
2

3
package windows
4

5
import (
6
	"syscall"
7
	"unsafe"
8
)
9

10
var _ unsafe.Pointer
11

12
// Do the interface allocations only once for common
13
// Errno values.
14
const (
15
	errnoERROR_IO_PENDING = 997
16
)
17

18
var (
19
	errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING)
20
	errERROR_EINVAL     error = syscall.EINVAL
21
)
22

23
// errnoErr returns common boxed Errno values, to prevent
24
// allocations at runtime.
25
func errnoErr(e syscall.Errno) error {
26
	switch e {
27
	case 0:
28
		return errERROR_EINVAL
29
	case errnoERROR_IO_PENDING:
30
		return errERROR_IO_PENDING
31
	}
32
	// TODO: add more here, after collecting data on the common
33
	// error values see on Windows. (perhaps when running
34
	// all.bat?)
35
	return e
36
}
37

38
var (
39
	modCfgMgr32 = NewLazySystemDLL("CfgMgr32.dll")
40
	modadvapi32 = NewLazySystemDLL("advapi32.dll")
41
	modcrypt32  = NewLazySystemDLL("crypt32.dll")
42
	moddnsapi   = NewLazySystemDLL("dnsapi.dll")
43
	moddwmapi   = NewLazySystemDLL("dwmapi.dll")
44
	modiphlpapi = NewLazySystemDLL("iphlpapi.dll")
45
	modkernel32 = NewLazySystemDLL("kernel32.dll")
46
	modmswsock  = NewLazySystemDLL("mswsock.dll")
47
	modnetapi32 = NewLazySystemDLL("netapi32.dll")
48
	modntdll    = NewLazySystemDLL("ntdll.dll")
49
	modole32    = NewLazySystemDLL("ole32.dll")
50
	modpsapi    = NewLazySystemDLL("psapi.dll")
51
	modsechost  = NewLazySystemDLL("sechost.dll")
52
	modsecur32  = NewLazySystemDLL("secur32.dll")
53
	modsetupapi = NewLazySystemDLL("setupapi.dll")
54
	modshell32  = NewLazySystemDLL("shell32.dll")
55
	moduser32   = NewLazySystemDLL("user32.dll")
56
	moduserenv  = NewLazySystemDLL("userenv.dll")
57
	modversion  = NewLazySystemDLL("version.dll")
58
	modwinmm    = NewLazySystemDLL("winmm.dll")
59
	modwintrust = NewLazySystemDLL("wintrust.dll")
60
	modws2_32   = NewLazySystemDLL("ws2_32.dll")
61
	modwtsapi32 = NewLazySystemDLL("wtsapi32.dll")
62

63
	procCM_Get_DevNode_Status                                = modCfgMgr32.NewProc("CM_Get_DevNode_Status")
64
	procCM_Get_Device_Interface_ListW                        = modCfgMgr32.NewProc("CM_Get_Device_Interface_ListW")
65
	procCM_Get_Device_Interface_List_SizeW                   = modCfgMgr32.NewProc("CM_Get_Device_Interface_List_SizeW")
66
	procCM_MapCrToWin32Err                                   = modCfgMgr32.NewProc("CM_MapCrToWin32Err")
67
	procAdjustTokenGroups                                    = modadvapi32.NewProc("AdjustTokenGroups")
68
	procAdjustTokenPrivileges                                = modadvapi32.NewProc("AdjustTokenPrivileges")
69
	procAllocateAndInitializeSid                             = modadvapi32.NewProc("AllocateAndInitializeSid")
70
	procBuildSecurityDescriptorW                             = modadvapi32.NewProc("BuildSecurityDescriptorW")
71
	procChangeServiceConfig2W                                = modadvapi32.NewProc("ChangeServiceConfig2W")
72
	procChangeServiceConfigW                                 = modadvapi32.NewProc("ChangeServiceConfigW")
73
	procCheckTokenMembership                                 = modadvapi32.NewProc("CheckTokenMembership")
74
	procCloseServiceHandle                                   = modadvapi32.NewProc("CloseServiceHandle")
75
	procControlService                                       = modadvapi32.NewProc("ControlService")
76
	procConvertSecurityDescriptorToStringSecurityDescriptorW = modadvapi32.NewProc("ConvertSecurityDescriptorToStringSecurityDescriptorW")
77
	procConvertSidToStringSidW                               = modadvapi32.NewProc("ConvertSidToStringSidW")
78
	procConvertStringSecurityDescriptorToSecurityDescriptorW = modadvapi32.NewProc("ConvertStringSecurityDescriptorToSecurityDescriptorW")
79
	procConvertStringSidToSidW                               = modadvapi32.NewProc("ConvertStringSidToSidW")
80
	procCopySid                                              = modadvapi32.NewProc("CopySid")
81
	procCreateProcessAsUserW                                 = modadvapi32.NewProc("CreateProcessAsUserW")
82
	procCreateServiceW                                       = modadvapi32.NewProc("CreateServiceW")
83
	procCreateWellKnownSid                                   = modadvapi32.NewProc("CreateWellKnownSid")
84
	procCryptAcquireContextW                                 = modadvapi32.NewProc("CryptAcquireContextW")
85
	procCryptGenRandom                                       = modadvapi32.NewProc("CryptGenRandom")
86
	procCryptReleaseContext                                  = modadvapi32.NewProc("CryptReleaseContext")
87
	procDeleteService                                        = modadvapi32.NewProc("DeleteService")
88
	procDeregisterEventSource                                = modadvapi32.NewProc("DeregisterEventSource")
89
	procDuplicateTokenEx                                     = modadvapi32.NewProc("DuplicateTokenEx")
90
	procEnumDependentServicesW                               = modadvapi32.NewProc("EnumDependentServicesW")
91
	procEnumServicesStatusExW                                = modadvapi32.NewProc("EnumServicesStatusExW")
92
	procEqualSid                                             = modadvapi32.NewProc("EqualSid")
93
	procFreeSid                                              = modadvapi32.NewProc("FreeSid")
94
	procGetAce                                               = modadvapi32.NewProc("GetAce")
95
	procGetLengthSid                                         = modadvapi32.NewProc("GetLengthSid")
96
	procGetNamedSecurityInfoW                                = modadvapi32.NewProc("GetNamedSecurityInfoW")
97
	procGetSecurityDescriptorControl                         = modadvapi32.NewProc("GetSecurityDescriptorControl")
98
	procGetSecurityDescriptorDacl                            = modadvapi32.NewProc("GetSecurityDescriptorDacl")
99
	procGetSecurityDescriptorGroup                           = modadvapi32.NewProc("GetSecurityDescriptorGroup")
100
	procGetSecurityDescriptorLength                          = modadvapi32.NewProc("GetSecurityDescriptorLength")
101
	procGetSecurityDescriptorOwner                           = modadvapi32.NewProc("GetSecurityDescriptorOwner")
102
	procGetSecurityDescriptorRMControl                       = modadvapi32.NewProc("GetSecurityDescriptorRMControl")
103
	procGetSecurityDescriptorSacl                            = modadvapi32.NewProc("GetSecurityDescriptorSacl")
104
	procGetSecurityInfo                                      = modadvapi32.NewProc("GetSecurityInfo")
105
	procGetSidIdentifierAuthority                            = modadvapi32.NewProc("GetSidIdentifierAuthority")
106
	procGetSidSubAuthority                                   = modadvapi32.NewProc("GetSidSubAuthority")
107
	procGetSidSubAuthorityCount                              = modadvapi32.NewProc("GetSidSubAuthorityCount")
108
	procGetTokenInformation                                  = modadvapi32.NewProc("GetTokenInformation")
109
	procImpersonateSelf                                      = modadvapi32.NewProc("ImpersonateSelf")
110
	procInitializeSecurityDescriptor                         = modadvapi32.NewProc("InitializeSecurityDescriptor")
111
	procInitiateSystemShutdownExW                            = modadvapi32.NewProc("InitiateSystemShutdownExW")
112
	procIsTokenRestricted                                    = modadvapi32.NewProc("IsTokenRestricted")
113
	procIsValidSecurityDescriptor                            = modadvapi32.NewProc("IsValidSecurityDescriptor")
114
	procIsValidSid                                           = modadvapi32.NewProc("IsValidSid")
115
	procIsWellKnownSid                                       = modadvapi32.NewProc("IsWellKnownSid")
116
	procLookupAccountNameW                                   = modadvapi32.NewProc("LookupAccountNameW")
117
	procLookupAccountSidW                                    = modadvapi32.NewProc("LookupAccountSidW")
118
	procLookupPrivilegeValueW                                = modadvapi32.NewProc("LookupPrivilegeValueW")
119
	procMakeAbsoluteSD                                       = modadvapi32.NewProc("MakeAbsoluteSD")
120
	procMakeSelfRelativeSD                                   = modadvapi32.NewProc("MakeSelfRelativeSD")
121
	procNotifyServiceStatusChangeW                           = modadvapi32.NewProc("NotifyServiceStatusChangeW")
122
	procOpenProcessToken                                     = modadvapi32.NewProc("OpenProcessToken")
123
	procOpenSCManagerW                                       = modadvapi32.NewProc("OpenSCManagerW")
124
	procOpenServiceW                                         = modadvapi32.NewProc("OpenServiceW")
125
	procOpenThreadToken                                      = modadvapi32.NewProc("OpenThreadToken")
126
	procQueryServiceConfig2W                                 = modadvapi32.NewProc("QueryServiceConfig2W")
127
	procQueryServiceConfigW                                  = modadvapi32.NewProc("QueryServiceConfigW")
128
	procQueryServiceDynamicInformation                       = modadvapi32.NewProc("QueryServiceDynamicInformation")
129
	procQueryServiceLockStatusW                              = modadvapi32.NewProc("QueryServiceLockStatusW")
130
	procQueryServiceStatus                                   = modadvapi32.NewProc("QueryServiceStatus")
131
	procQueryServiceStatusEx                                 = modadvapi32.NewProc("QueryServiceStatusEx")
132
	procRegCloseKey                                          = modadvapi32.NewProc("RegCloseKey")
133
	procRegEnumKeyExW                                        = modadvapi32.NewProc("RegEnumKeyExW")
134
	procRegNotifyChangeKeyValue                              = modadvapi32.NewProc("RegNotifyChangeKeyValue")
135
	procRegOpenKeyExW                                        = modadvapi32.NewProc("RegOpenKeyExW")
136
	procRegQueryInfoKeyW                                     = modadvapi32.NewProc("RegQueryInfoKeyW")
137
	procRegQueryValueExW                                     = modadvapi32.NewProc("RegQueryValueExW")
138
	procRegisterEventSourceW                                 = modadvapi32.NewProc("RegisterEventSourceW")
139
	procRegisterServiceCtrlHandlerExW                        = modadvapi32.NewProc("RegisterServiceCtrlHandlerExW")
140
	procReportEventW                                         = modadvapi32.NewProc("ReportEventW")
141
	procRevertToSelf                                         = modadvapi32.NewProc("RevertToSelf")
142
	procSetEntriesInAclW                                     = modadvapi32.NewProc("SetEntriesInAclW")
143
	procSetKernelObjectSecurity                              = modadvapi32.NewProc("SetKernelObjectSecurity")
144
	procSetNamedSecurityInfoW                                = modadvapi32.NewProc("SetNamedSecurityInfoW")
145
	procSetSecurityDescriptorControl                         = modadvapi32.NewProc("SetSecurityDescriptorControl")
146
	procSetSecurityDescriptorDacl                            = modadvapi32.NewProc("SetSecurityDescriptorDacl")
147
	procSetSecurityDescriptorGroup                           = modadvapi32.NewProc("SetSecurityDescriptorGroup")
148
	procSetSecurityDescriptorOwner                           = modadvapi32.NewProc("SetSecurityDescriptorOwner")
149
	procSetSecurityDescriptorRMControl                       = modadvapi32.NewProc("SetSecurityDescriptorRMControl")
150
	procSetSecurityDescriptorSacl                            = modadvapi32.NewProc("SetSecurityDescriptorSacl")
151
	procSetSecurityInfo                                      = modadvapi32.NewProc("SetSecurityInfo")
152
	procSetServiceStatus                                     = modadvapi32.NewProc("SetServiceStatus")
153
	procSetThreadToken                                       = modadvapi32.NewProc("SetThreadToken")
154
	procSetTokenInformation                                  = modadvapi32.NewProc("SetTokenInformation")
155
	procStartServiceCtrlDispatcherW                          = modadvapi32.NewProc("StartServiceCtrlDispatcherW")
156
	procStartServiceW                                        = modadvapi32.NewProc("StartServiceW")
157
	procCertAddCertificateContextToStore                     = modcrypt32.NewProc("CertAddCertificateContextToStore")
158
	procCertCloseStore                                       = modcrypt32.NewProc("CertCloseStore")
159
	procCertCreateCertificateContext                         = modcrypt32.NewProc("CertCreateCertificateContext")
160
	procCertDeleteCertificateFromStore                       = modcrypt32.NewProc("CertDeleteCertificateFromStore")
161
	procCertDuplicateCertificateContext                      = modcrypt32.NewProc("CertDuplicateCertificateContext")
162
	procCertEnumCertificatesInStore                          = modcrypt32.NewProc("CertEnumCertificatesInStore")
163
	procCertFindCertificateInStore                           = modcrypt32.NewProc("CertFindCertificateInStore")
164
	procCertFindChainInStore                                 = modcrypt32.NewProc("CertFindChainInStore")
165
	procCertFindExtension                                    = modcrypt32.NewProc("CertFindExtension")
166
	procCertFreeCertificateChain                             = modcrypt32.NewProc("CertFreeCertificateChain")
167
	procCertFreeCertificateContext                           = modcrypt32.NewProc("CertFreeCertificateContext")
168
	procCertGetCertificateChain                              = modcrypt32.NewProc("CertGetCertificateChain")
169
	procCertGetNameStringW                                   = modcrypt32.NewProc("CertGetNameStringW")
170
	procCertOpenStore                                        = modcrypt32.NewProc("CertOpenStore")
171
	procCertOpenSystemStoreW                                 = modcrypt32.NewProc("CertOpenSystemStoreW")
172
	procCertVerifyCertificateChainPolicy                     = modcrypt32.NewProc("CertVerifyCertificateChainPolicy")
173
	procCryptAcquireCertificatePrivateKey                    = modcrypt32.NewProc("CryptAcquireCertificatePrivateKey")
174
	procCryptDecodeObject                                    = modcrypt32.NewProc("CryptDecodeObject")
175
	procCryptProtectData                                     = modcrypt32.NewProc("CryptProtectData")
176
	procCryptQueryObject                                     = modcrypt32.NewProc("CryptQueryObject")
177
	procCryptUnprotectData                                   = modcrypt32.NewProc("CryptUnprotectData")
178
	procPFXImportCertStore                                   = modcrypt32.NewProc("PFXImportCertStore")
179
	procDnsNameCompare_W                                     = moddnsapi.NewProc("DnsNameCompare_W")
180
	procDnsQuery_W                                           = moddnsapi.NewProc("DnsQuery_W")
181
	procDnsRecordListFree                                    = moddnsapi.NewProc("DnsRecordListFree")
182
	procDwmGetWindowAttribute                                = moddwmapi.NewProc("DwmGetWindowAttribute")
183
	procDwmSetWindowAttribute                                = moddwmapi.NewProc("DwmSetWindowAttribute")
184
	procCancelMibChangeNotify2                               = modiphlpapi.NewProc("CancelMibChangeNotify2")
185
	procGetAdaptersAddresses                                 = modiphlpapi.NewProc("GetAdaptersAddresses")
186
	procGetAdaptersInfo                                      = modiphlpapi.NewProc("GetAdaptersInfo")
187
	procGetBestInterfaceEx                                   = modiphlpapi.NewProc("GetBestInterfaceEx")
188
	procGetIfEntry                                           = modiphlpapi.NewProc("GetIfEntry")
189
	procGetIfEntry2Ex                                        = modiphlpapi.NewProc("GetIfEntry2Ex")
190
	procGetUnicastIpAddressEntry                             = modiphlpapi.NewProc("GetUnicastIpAddressEntry")
191
	procNotifyIpInterfaceChange                              = modiphlpapi.NewProc("NotifyIpInterfaceChange")
192
	procNotifyUnicastIpAddressChange                         = modiphlpapi.NewProc("NotifyUnicastIpAddressChange")
193
	procAddDllDirectory                                      = modkernel32.NewProc("AddDllDirectory")
194
	procAssignProcessToJobObject                             = modkernel32.NewProc("AssignProcessToJobObject")
195
	procCancelIo                                             = modkernel32.NewProc("CancelIo")
196
	procCancelIoEx                                           = modkernel32.NewProc("CancelIoEx")
197
	procClearCommBreak                                       = modkernel32.NewProc("ClearCommBreak")
198
	procClearCommError                                       = modkernel32.NewProc("ClearCommError")
199
	procCloseHandle                                          = modkernel32.NewProc("CloseHandle")
200
	procClosePseudoConsole                                   = modkernel32.NewProc("ClosePseudoConsole")
201
	procConnectNamedPipe                                     = modkernel32.NewProc("ConnectNamedPipe")
202
	procCreateDirectoryW                                     = modkernel32.NewProc("CreateDirectoryW")
203
	procCreateEventExW                                       = modkernel32.NewProc("CreateEventExW")
204
	procCreateEventW                                         = modkernel32.NewProc("CreateEventW")
205
	procCreateFileMappingW                                   = modkernel32.NewProc("CreateFileMappingW")
206
	procCreateFileW                                          = modkernel32.NewProc("CreateFileW")
207
	procCreateHardLinkW                                      = modkernel32.NewProc("CreateHardLinkW")
208
	procCreateIoCompletionPort                               = modkernel32.NewProc("CreateIoCompletionPort")
209
	procCreateJobObjectW                                     = modkernel32.NewProc("CreateJobObjectW")
210
	procCreateMutexExW                                       = modkernel32.NewProc("CreateMutexExW")
211
	procCreateMutexW                                         = modkernel32.NewProc("CreateMutexW")
212
	procCreateNamedPipeW                                     = modkernel32.NewProc("CreateNamedPipeW")
213
	procCreatePipe                                           = modkernel32.NewProc("CreatePipe")
214
	procCreateProcessW                                       = modkernel32.NewProc("CreateProcessW")
215
	procCreatePseudoConsole                                  = modkernel32.NewProc("CreatePseudoConsole")
216
	procCreateSymbolicLinkW                                  = modkernel32.NewProc("CreateSymbolicLinkW")
217
	procCreateToolhelp32Snapshot                             = modkernel32.NewProc("CreateToolhelp32Snapshot")
218
	procDefineDosDeviceW                                     = modkernel32.NewProc("DefineDosDeviceW")
219
	procDeleteFileW                                          = modkernel32.NewProc("DeleteFileW")
220
	procDeleteProcThreadAttributeList                        = modkernel32.NewProc("DeleteProcThreadAttributeList")
221
	procDeleteVolumeMountPointW                              = modkernel32.NewProc("DeleteVolumeMountPointW")
222
	procDeviceIoControl                                      = modkernel32.NewProc("DeviceIoControl")
223
	procDisconnectNamedPipe                                  = modkernel32.NewProc("DisconnectNamedPipe")
224
	procDuplicateHandle                                      = modkernel32.NewProc("DuplicateHandle")
225
	procEscapeCommFunction                                   = modkernel32.NewProc("EscapeCommFunction")
226
	procExitProcess                                          = modkernel32.NewProc("ExitProcess")
227
	procExpandEnvironmentStringsW                            = modkernel32.NewProc("ExpandEnvironmentStringsW")
228
	procFindClose                                            = modkernel32.NewProc("FindClose")
229
	procFindCloseChangeNotification                          = modkernel32.NewProc("FindCloseChangeNotification")
230
	procFindFirstChangeNotificationW                         = modkernel32.NewProc("FindFirstChangeNotificationW")
231
	procFindFirstFileW                                       = modkernel32.NewProc("FindFirstFileW")
232
	procFindFirstVolumeMountPointW                           = modkernel32.NewProc("FindFirstVolumeMountPointW")
233
	procFindFirstVolumeW                                     = modkernel32.NewProc("FindFirstVolumeW")
234
	procFindNextChangeNotification                           = modkernel32.NewProc("FindNextChangeNotification")
235
	procFindNextFileW                                        = modkernel32.NewProc("FindNextFileW")
236
	procFindNextVolumeMountPointW                            = modkernel32.NewProc("FindNextVolumeMountPointW")
237
	procFindNextVolumeW                                      = modkernel32.NewProc("FindNextVolumeW")
238
	procFindResourceW                                        = modkernel32.NewProc("FindResourceW")
239
	procFindVolumeClose                                      = modkernel32.NewProc("FindVolumeClose")
240
	procFindVolumeMountPointClose                            = modkernel32.NewProc("FindVolumeMountPointClose")
241
	procFlushConsoleInputBuffer                              = modkernel32.NewProc("FlushConsoleInputBuffer")
242
	procFlushFileBuffers                                     = modkernel32.NewProc("FlushFileBuffers")
243
	procFlushViewOfFile                                      = modkernel32.NewProc("FlushViewOfFile")
244
	procFormatMessageW                                       = modkernel32.NewProc("FormatMessageW")
245
	procFreeEnvironmentStringsW                              = modkernel32.NewProc("FreeEnvironmentStringsW")
246
	procFreeLibrary                                          = modkernel32.NewProc("FreeLibrary")
247
	procGenerateConsoleCtrlEvent                             = modkernel32.NewProc("GenerateConsoleCtrlEvent")
248
	procGetACP                                               = modkernel32.NewProc("GetACP")
249
	procGetActiveProcessorCount                              = modkernel32.NewProc("GetActiveProcessorCount")
250
	procGetCommModemStatus                                   = modkernel32.NewProc("GetCommModemStatus")
251
	procGetCommState                                         = modkernel32.NewProc("GetCommState")
252
	procGetCommTimeouts                                      = modkernel32.NewProc("GetCommTimeouts")
253
	procGetCommandLineW                                      = modkernel32.NewProc("GetCommandLineW")
254
	procGetComputerNameExW                                   = modkernel32.NewProc("GetComputerNameExW")
255
	procGetComputerNameW                                     = modkernel32.NewProc("GetComputerNameW")
256
	procGetConsoleCP                                         = modkernel32.NewProc("GetConsoleCP")
257
	procGetConsoleMode                                       = modkernel32.NewProc("GetConsoleMode")
258
	procGetConsoleOutputCP                                   = modkernel32.NewProc("GetConsoleOutputCP")
259
	procGetConsoleScreenBufferInfo                           = modkernel32.NewProc("GetConsoleScreenBufferInfo")
260
	procGetCurrentDirectoryW                                 = modkernel32.NewProc("GetCurrentDirectoryW")
261
	procGetCurrentProcessId                                  = modkernel32.NewProc("GetCurrentProcessId")
262
	procGetCurrentThreadId                                   = modkernel32.NewProc("GetCurrentThreadId")
263
	procGetDiskFreeSpaceExW                                  = modkernel32.NewProc("GetDiskFreeSpaceExW")
264
	procGetDriveTypeW                                        = modkernel32.NewProc("GetDriveTypeW")
265
	procGetEnvironmentStringsW                               = modkernel32.NewProc("GetEnvironmentStringsW")
266
	procGetEnvironmentVariableW                              = modkernel32.NewProc("GetEnvironmentVariableW")
267
	procGetExitCodeProcess                                   = modkernel32.NewProc("GetExitCodeProcess")
268
	procGetFileAttributesExW                                 = modkernel32.NewProc("GetFileAttributesExW")
269
	procGetFileAttributesW                                   = modkernel32.NewProc("GetFileAttributesW")
270
	procGetFileInformationByHandle                           = modkernel32.NewProc("GetFileInformationByHandle")
271
	procGetFileInformationByHandleEx                         = modkernel32.NewProc("GetFileInformationByHandleEx")
272
	procGetFileTime                                          = modkernel32.NewProc("GetFileTime")
273
	procGetFileType                                          = modkernel32.NewProc("GetFileType")
274
	procGetFinalPathNameByHandleW                            = modkernel32.NewProc("GetFinalPathNameByHandleW")
275
	procGetFullPathNameW                                     = modkernel32.NewProc("GetFullPathNameW")
276
	procGetLargePageMinimum                                  = modkernel32.NewProc("GetLargePageMinimum")
277
	procGetLastError                                         = modkernel32.NewProc("GetLastError")
278
	procGetLogicalDriveStringsW                              = modkernel32.NewProc("GetLogicalDriveStringsW")
279
	procGetLogicalDrives                                     = modkernel32.NewProc("GetLogicalDrives")
280
	procGetLongPathNameW                                     = modkernel32.NewProc("GetLongPathNameW")
281
	procGetMaximumProcessorCount                             = modkernel32.NewProc("GetMaximumProcessorCount")
282
	procGetModuleFileNameW                                   = modkernel32.NewProc("GetModuleFileNameW")
283
	procGetModuleHandleExW                                   = modkernel32.NewProc("GetModuleHandleExW")
284
	procGetNamedPipeClientProcessId                          = modkernel32.NewProc("GetNamedPipeClientProcessId")
285
	procGetNamedPipeHandleStateW                             = modkernel32.NewProc("GetNamedPipeHandleStateW")
286
	procGetNamedPipeInfo                                     = modkernel32.NewProc("GetNamedPipeInfo")
287
	procGetNamedPipeServerProcessId                          = modkernel32.NewProc("GetNamedPipeServerProcessId")
288
	procGetNumberOfConsoleInputEvents                        = modkernel32.NewProc("GetNumberOfConsoleInputEvents")
289
	procGetOverlappedResult                                  = modkernel32.NewProc("GetOverlappedResult")
290
	procGetPriorityClass                                     = modkernel32.NewProc("GetPriorityClass")
291
	procGetProcAddress                                       = modkernel32.NewProc("GetProcAddress")
292
	procGetProcessId                                         = modkernel32.NewProc("GetProcessId")
293
	procGetProcessPreferredUILanguages                       = modkernel32.NewProc("GetProcessPreferredUILanguages")
294
	procGetProcessShutdownParameters                         = modkernel32.NewProc("GetProcessShutdownParameters")
295
	procGetProcessTimes                                      = modkernel32.NewProc("GetProcessTimes")
296
	procGetProcessWorkingSetSizeEx                           = modkernel32.NewProc("GetProcessWorkingSetSizeEx")
297
	procGetQueuedCompletionStatus                            = modkernel32.NewProc("GetQueuedCompletionStatus")
298
	procGetShortPathNameW                                    = modkernel32.NewProc("GetShortPathNameW")
299
	procGetStartupInfoW                                      = modkernel32.NewProc("GetStartupInfoW")
300
	procGetStdHandle                                         = modkernel32.NewProc("GetStdHandle")
301
	procGetSystemDirectoryW                                  = modkernel32.NewProc("GetSystemDirectoryW")
302
	procGetSystemPreferredUILanguages                        = modkernel32.NewProc("GetSystemPreferredUILanguages")
303
	procGetSystemTimeAsFileTime                              = modkernel32.NewProc("GetSystemTimeAsFileTime")
304
	procGetSystemTimePreciseAsFileTime                       = modkernel32.NewProc("GetSystemTimePreciseAsFileTime")
305
	procGetSystemWindowsDirectoryW                           = modkernel32.NewProc("GetSystemWindowsDirectoryW")
306
	procGetTempPathW                                         = modkernel32.NewProc("GetTempPathW")
307
	procGetThreadPreferredUILanguages                        = modkernel32.NewProc("GetThreadPreferredUILanguages")
308
	procGetTickCount64                                       = modkernel32.NewProc("GetTickCount64")
309
	procGetTimeZoneInformation                               = modkernel32.NewProc("GetTimeZoneInformation")
310
	procGetUserPreferredUILanguages                          = modkernel32.NewProc("GetUserPreferredUILanguages")
311
	procGetVersion                                           = modkernel32.NewProc("GetVersion")
312
	procGetVolumeInformationByHandleW                        = modkernel32.NewProc("GetVolumeInformationByHandleW")
313
	procGetVolumeInformationW                                = modkernel32.NewProc("GetVolumeInformationW")
314
	procGetVolumeNameForVolumeMountPointW                    = modkernel32.NewProc("GetVolumeNameForVolumeMountPointW")
315
	procGetVolumePathNameW                                   = modkernel32.NewProc("GetVolumePathNameW")
316
	procGetVolumePathNamesForVolumeNameW                     = modkernel32.NewProc("GetVolumePathNamesForVolumeNameW")
317
	procGetWindowsDirectoryW                                 = modkernel32.NewProc("GetWindowsDirectoryW")
318
	procInitializeProcThreadAttributeList                    = modkernel32.NewProc("InitializeProcThreadAttributeList")
319
	procIsWow64Process                                       = modkernel32.NewProc("IsWow64Process")
320
	procIsWow64Process2                                      = modkernel32.NewProc("IsWow64Process2")
321
	procLoadLibraryExW                                       = modkernel32.NewProc("LoadLibraryExW")
322
	procLoadLibraryW                                         = modkernel32.NewProc("LoadLibraryW")
323
	procLoadResource                                         = modkernel32.NewProc("LoadResource")
324
	procLocalAlloc                                           = modkernel32.NewProc("LocalAlloc")
325
	procLocalFree                                            = modkernel32.NewProc("LocalFree")
326
	procLockFileEx                                           = modkernel32.NewProc("LockFileEx")
327
	procLockResource                                         = modkernel32.NewProc("LockResource")
328
	procMapViewOfFile                                        = modkernel32.NewProc("MapViewOfFile")
329
	procModule32FirstW                                       = modkernel32.NewProc("Module32FirstW")
330
	procModule32NextW                                        = modkernel32.NewProc("Module32NextW")
331
	procMoveFileExW                                          = modkernel32.NewProc("MoveFileExW")
332
	procMoveFileW                                            = modkernel32.NewProc("MoveFileW")
333
	procMultiByteToWideChar                                  = modkernel32.NewProc("MultiByteToWideChar")
334
	procOpenEventW                                           = modkernel32.NewProc("OpenEventW")
335
	procOpenMutexW                                           = modkernel32.NewProc("OpenMutexW")
336
	procOpenProcess                                          = modkernel32.NewProc("OpenProcess")
337
	procOpenThread                                           = modkernel32.NewProc("OpenThread")
338
	procPostQueuedCompletionStatus                           = modkernel32.NewProc("PostQueuedCompletionStatus")
339
	procProcess32FirstW                                      = modkernel32.NewProc("Process32FirstW")
340
	procProcess32NextW                                       = modkernel32.NewProc("Process32NextW")
341
	procProcessIdToSessionId                                 = modkernel32.NewProc("ProcessIdToSessionId")
342
	procPulseEvent                                           = modkernel32.NewProc("PulseEvent")
343
	procPurgeComm                                            = modkernel32.NewProc("PurgeComm")
344
	procQueryDosDeviceW                                      = modkernel32.NewProc("QueryDosDeviceW")
345
	procQueryFullProcessImageNameW                           = modkernel32.NewProc("QueryFullProcessImageNameW")
346
	procQueryInformationJobObject                            = modkernel32.NewProc("QueryInformationJobObject")
347
	procReadConsoleW                                         = modkernel32.NewProc("ReadConsoleW")
348
	procReadDirectoryChangesW                                = modkernel32.NewProc("ReadDirectoryChangesW")
349
	procReadFile                                             = modkernel32.NewProc("ReadFile")
350
	procReadProcessMemory                                    = modkernel32.NewProc("ReadProcessMemory")
351
	procReleaseMutex                                         = modkernel32.NewProc("ReleaseMutex")
352
	procRemoveDirectoryW                                     = modkernel32.NewProc("RemoveDirectoryW")
353
	procRemoveDllDirectory                                   = modkernel32.NewProc("RemoveDllDirectory")
354
	procResetEvent                                           = modkernel32.NewProc("ResetEvent")
355
	procResizePseudoConsole                                  = modkernel32.NewProc("ResizePseudoConsole")
356
	procResumeThread                                         = modkernel32.NewProc("ResumeThread")
357
	procSetCommBreak                                         = modkernel32.NewProc("SetCommBreak")
358
	procSetCommMask                                          = modkernel32.NewProc("SetCommMask")
359
	procSetCommState                                         = modkernel32.NewProc("SetCommState")
360
	procSetCommTimeouts                                      = modkernel32.NewProc("SetCommTimeouts")
361
	procSetConsoleCP                                         = modkernel32.NewProc("SetConsoleCP")
362
	procSetConsoleCursorPosition                             = modkernel32.NewProc("SetConsoleCursorPosition")
363
	procSetConsoleMode                                       = modkernel32.NewProc("SetConsoleMode")
364
	procSetConsoleOutputCP                                   = modkernel32.NewProc("SetConsoleOutputCP")
365
	procSetCurrentDirectoryW                                 = modkernel32.NewProc("SetCurrentDirectoryW")
366
	procSetDefaultDllDirectories                             = modkernel32.NewProc("SetDefaultDllDirectories")
367
	procSetDllDirectoryW                                     = modkernel32.NewProc("SetDllDirectoryW")
368
	procSetEndOfFile                                         = modkernel32.NewProc("SetEndOfFile")
369
	procSetEnvironmentVariableW                              = modkernel32.NewProc("SetEnvironmentVariableW")
370
	procSetErrorMode                                         = modkernel32.NewProc("SetErrorMode")
371
	procSetEvent                                             = modkernel32.NewProc("SetEvent")
372
	procSetFileAttributesW                                   = modkernel32.NewProc("SetFileAttributesW")
373
	procSetFileCompletionNotificationModes                   = modkernel32.NewProc("SetFileCompletionNotificationModes")
374
	procSetFileInformationByHandle                           = modkernel32.NewProc("SetFileInformationByHandle")
375
	procSetFilePointer                                       = modkernel32.NewProc("SetFilePointer")
376
	procSetFileTime                                          = modkernel32.NewProc("SetFileTime")
377
	procSetFileValidData                                     = modkernel32.NewProc("SetFileValidData")
378
	procSetHandleInformation                                 = modkernel32.NewProc("SetHandleInformation")
379
	procSetInformationJobObject                              = modkernel32.NewProc("SetInformationJobObject")
380
	procSetNamedPipeHandleState                              = modkernel32.NewProc("SetNamedPipeHandleState")
381
	procSetPriorityClass                                     = modkernel32.NewProc("SetPriorityClass")
382
	procSetProcessPriorityBoost                              = modkernel32.NewProc("SetProcessPriorityBoost")
383
	procSetProcessShutdownParameters                         = modkernel32.NewProc("SetProcessShutdownParameters")
384
	procSetProcessWorkingSetSizeEx                           = modkernel32.NewProc("SetProcessWorkingSetSizeEx")
385
	procSetStdHandle                                         = modkernel32.NewProc("SetStdHandle")
386
	procSetVolumeLabelW                                      = modkernel32.NewProc("SetVolumeLabelW")
387
	procSetVolumeMountPointW                                 = modkernel32.NewProc("SetVolumeMountPointW")
388
	procSetupComm                                            = modkernel32.NewProc("SetupComm")
389
	procSizeofResource                                       = modkernel32.NewProc("SizeofResource")
390
	procSleepEx                                              = modkernel32.NewProc("SleepEx")
391
	procTerminateJobObject                                   = modkernel32.NewProc("TerminateJobObject")
392
	procTerminateProcess                                     = modkernel32.NewProc("TerminateProcess")
393
	procThread32First                                        = modkernel32.NewProc("Thread32First")
394
	procThread32Next                                         = modkernel32.NewProc("Thread32Next")
395
	procUnlockFileEx                                         = modkernel32.NewProc("UnlockFileEx")
396
	procUnmapViewOfFile                                      = modkernel32.NewProc("UnmapViewOfFile")
397
	procUpdateProcThreadAttribute                            = modkernel32.NewProc("UpdateProcThreadAttribute")
398
	procVirtualAlloc                                         = modkernel32.NewProc("VirtualAlloc")
399
	procVirtualFree                                          = modkernel32.NewProc("VirtualFree")
400
	procVirtualLock                                          = modkernel32.NewProc("VirtualLock")
401
	procVirtualProtect                                       = modkernel32.NewProc("VirtualProtect")
402
	procVirtualProtectEx                                     = modkernel32.NewProc("VirtualProtectEx")
403
	procVirtualQuery                                         = modkernel32.NewProc("VirtualQuery")
404
	procVirtualQueryEx                                       = modkernel32.NewProc("VirtualQueryEx")
405
	procVirtualUnlock                                        = modkernel32.NewProc("VirtualUnlock")
406
	procWTSGetActiveConsoleSessionId                         = modkernel32.NewProc("WTSGetActiveConsoleSessionId")
407
	procWaitCommEvent                                        = modkernel32.NewProc("WaitCommEvent")
408
	procWaitForMultipleObjects                               = modkernel32.NewProc("WaitForMultipleObjects")
409
	procWaitForSingleObject                                  = modkernel32.NewProc("WaitForSingleObject")
410
	procWriteConsoleW                                        = modkernel32.NewProc("WriteConsoleW")
411
	procWriteFile                                            = modkernel32.NewProc("WriteFile")
412
	procWriteProcessMemory                                   = modkernel32.NewProc("WriteProcessMemory")
413
	procAcceptEx                                             = modmswsock.NewProc("AcceptEx")
414
	procGetAcceptExSockaddrs                                 = modmswsock.NewProc("GetAcceptExSockaddrs")
415
	procTransmitFile                                         = modmswsock.NewProc("TransmitFile")
416
	procNetApiBufferFree                                     = modnetapi32.NewProc("NetApiBufferFree")
417
	procNetGetJoinInformation                                = modnetapi32.NewProc("NetGetJoinInformation")
418
	procNetUserEnum                                          = modnetapi32.NewProc("NetUserEnum")
419
	procNetUserGetInfo                                       = modnetapi32.NewProc("NetUserGetInfo")
420
	procNtCreateFile                                         = modntdll.NewProc("NtCreateFile")
421
	procNtCreateNamedPipeFile                                = modntdll.NewProc("NtCreateNamedPipeFile")
422
	procNtQueryInformationProcess                            = modntdll.NewProc("NtQueryInformationProcess")
423
	procNtQuerySystemInformation                             = modntdll.NewProc("NtQuerySystemInformation")
424
	procNtSetInformationFile                                 = modntdll.NewProc("NtSetInformationFile")
425
	procNtSetInformationProcess                              = modntdll.NewProc("NtSetInformationProcess")
426
	procNtSetSystemInformation                               = modntdll.NewProc("NtSetSystemInformation")
427
	procRtlAddFunctionTable                                  = modntdll.NewProc("RtlAddFunctionTable")
428
	procRtlDefaultNpAcl                                      = modntdll.NewProc("RtlDefaultNpAcl")
429
	procRtlDeleteFunctionTable                               = modntdll.NewProc("RtlDeleteFunctionTable")
430
	procRtlDosPathNameToNtPathName_U_WithStatus              = modntdll.NewProc("RtlDosPathNameToNtPathName_U_WithStatus")
431
	procRtlDosPathNameToRelativeNtPathName_U_WithStatus      = modntdll.NewProc("RtlDosPathNameToRelativeNtPathName_U_WithStatus")
432
	procRtlGetCurrentPeb                                     = modntdll.NewProc("RtlGetCurrentPeb")
433
	procRtlGetNtVersionNumbers                               = modntdll.NewProc("RtlGetNtVersionNumbers")
434
	procRtlGetVersion                                        = modntdll.NewProc("RtlGetVersion")
435
	procRtlInitString                                        = modntdll.NewProc("RtlInitString")
436
	procRtlInitUnicodeString                                 = modntdll.NewProc("RtlInitUnicodeString")
437
	procRtlNtStatusToDosErrorNoTeb                           = modntdll.NewProc("RtlNtStatusToDosErrorNoTeb")
438
	procCLSIDFromString                                      = modole32.NewProc("CLSIDFromString")
439
	procCoCreateGuid                                         = modole32.NewProc("CoCreateGuid")
440
	procCoGetObject                                          = modole32.NewProc("CoGetObject")
441
	procCoInitializeEx                                       = modole32.NewProc("CoInitializeEx")
442
	procCoTaskMemFree                                        = modole32.NewProc("CoTaskMemFree")
443
	procCoUninitialize                                       = modole32.NewProc("CoUninitialize")
444
	procStringFromGUID2                                      = modole32.NewProc("StringFromGUID2")
445
	procEnumProcessModules                                   = modpsapi.NewProc("EnumProcessModules")
446
	procEnumProcessModulesEx                                 = modpsapi.NewProc("EnumProcessModulesEx")
447
	procEnumProcesses                                        = modpsapi.NewProc("EnumProcesses")
448
	procGetModuleBaseNameW                                   = modpsapi.NewProc("GetModuleBaseNameW")
449
	procGetModuleFileNameExW                                 = modpsapi.NewProc("GetModuleFileNameExW")
450
	procGetModuleInformation                                 = modpsapi.NewProc("GetModuleInformation")
451
	procQueryWorkingSetEx                                    = modpsapi.NewProc("QueryWorkingSetEx")
452
	procSubscribeServiceChangeNotifications                  = modsechost.NewProc("SubscribeServiceChangeNotifications")
453
	procUnsubscribeServiceChangeNotifications                = modsechost.NewProc("UnsubscribeServiceChangeNotifications")
454
	procGetUserNameExW                                       = modsecur32.NewProc("GetUserNameExW")
455
	procTranslateNameW                                       = modsecur32.NewProc("TranslateNameW")
456
	procSetupDiBuildDriverInfoList                           = modsetupapi.NewProc("SetupDiBuildDriverInfoList")
457
	procSetupDiCallClassInstaller                            = modsetupapi.NewProc("SetupDiCallClassInstaller")
458
	procSetupDiCancelDriverInfoSearch                        = modsetupapi.NewProc("SetupDiCancelDriverInfoSearch")
459
	procSetupDiClassGuidsFromNameExW                         = modsetupapi.NewProc("SetupDiClassGuidsFromNameExW")
460
	procSetupDiClassNameFromGuidExW                          = modsetupapi.NewProc("SetupDiClassNameFromGuidExW")
461
	procSetupDiCreateDeviceInfoListExW                       = modsetupapi.NewProc("SetupDiCreateDeviceInfoListExW")
462
	procSetupDiCreateDeviceInfoW                             = modsetupapi.NewProc("SetupDiCreateDeviceInfoW")
463
	procSetupDiDestroyDeviceInfoList                         = modsetupapi.NewProc("SetupDiDestroyDeviceInfoList")
464
	procSetupDiDestroyDriverInfoList                         = modsetupapi.NewProc("SetupDiDestroyDriverInfoList")
465
	procSetupDiEnumDeviceInfo                                = modsetupapi.NewProc("SetupDiEnumDeviceInfo")
466
	procSetupDiEnumDriverInfoW                               = modsetupapi.NewProc("SetupDiEnumDriverInfoW")
467
	procSetupDiGetClassDevsExW                               = modsetupapi.NewProc("SetupDiGetClassDevsExW")
468
	procSetupDiGetClassInstallParamsW                        = modsetupapi.NewProc("SetupDiGetClassInstallParamsW")
469
	procSetupDiGetDeviceInfoListDetailW                      = modsetupapi.NewProc("SetupDiGetDeviceInfoListDetailW")
470
	procSetupDiGetDeviceInstallParamsW                       = modsetupapi.NewProc("SetupDiGetDeviceInstallParamsW")
471
	procSetupDiGetDeviceInstanceIdW                          = modsetupapi.NewProc("SetupDiGetDeviceInstanceIdW")
472
	procSetupDiGetDevicePropertyW                            = modsetupapi.NewProc("SetupDiGetDevicePropertyW")
473
	procSetupDiGetDeviceRegistryPropertyW                    = modsetupapi.NewProc("SetupDiGetDeviceRegistryPropertyW")
474
	procSetupDiGetDriverInfoDetailW                          = modsetupapi.NewProc("SetupDiGetDriverInfoDetailW")
475
	procSetupDiGetSelectedDevice                             = modsetupapi.NewProc("SetupDiGetSelectedDevice")
476
	procSetupDiGetSelectedDriverW                            = modsetupapi.NewProc("SetupDiGetSelectedDriverW")
477
	procSetupDiOpenDevRegKey                                 = modsetupapi.NewProc("SetupDiOpenDevRegKey")
478
	procSetupDiSetClassInstallParamsW                        = modsetupapi.NewProc("SetupDiSetClassInstallParamsW")
479
	procSetupDiSetDeviceInstallParamsW                       = modsetupapi.NewProc("SetupDiSetDeviceInstallParamsW")
480
	procSetupDiSetDeviceRegistryPropertyW                    = modsetupapi.NewProc("SetupDiSetDeviceRegistryPropertyW")
481
	procSetupDiSetSelectedDevice                             = modsetupapi.NewProc("SetupDiSetSelectedDevice")
482
	procSetupDiSetSelectedDriverW                            = modsetupapi.NewProc("SetupDiSetSelectedDriverW")
483
	procSetupUninstallOEMInfW                                = modsetupapi.NewProc("SetupUninstallOEMInfW")
484
	procCommandLineToArgvW                                   = modshell32.NewProc("CommandLineToArgvW")
485
	procSHGetKnownFolderPath                                 = modshell32.NewProc("SHGetKnownFolderPath")
486
	procShellExecuteW                                        = modshell32.NewProc("ShellExecuteW")
487
	procEnumChildWindows                                     = moduser32.NewProc("EnumChildWindows")
488
	procEnumWindows                                          = moduser32.NewProc("EnumWindows")
489
	procExitWindowsEx                                        = moduser32.NewProc("ExitWindowsEx")
490
	procGetClassNameW                                        = moduser32.NewProc("GetClassNameW")
491
	procGetDesktopWindow                                     = moduser32.NewProc("GetDesktopWindow")
492
	procGetForegroundWindow                                  = moduser32.NewProc("GetForegroundWindow")
493
	procGetGUIThreadInfo                                     = moduser32.NewProc("GetGUIThreadInfo")
494
	procGetKeyboardLayout                                    = moduser32.NewProc("GetKeyboardLayout")
495
	procGetShellWindow                                       = moduser32.NewProc("GetShellWindow")
496
	procGetWindowThreadProcessId                             = moduser32.NewProc("GetWindowThreadProcessId")
497
	procIsWindow                                             = moduser32.NewProc("IsWindow")
498
	procIsWindowUnicode                                      = moduser32.NewProc("IsWindowUnicode")
499
	procIsWindowVisible                                      = moduser32.NewProc("IsWindowVisible")
500
	procLoadKeyboardLayoutW                                  = moduser32.NewProc("LoadKeyboardLayoutW")
501
	procMessageBoxW                                          = moduser32.NewProc("MessageBoxW")
502
	procToUnicodeEx                                          = moduser32.NewProc("ToUnicodeEx")
503
	procUnloadKeyboardLayout                                 = moduser32.NewProc("UnloadKeyboardLayout")
504
	procCreateEnvironmentBlock                               = moduserenv.NewProc("CreateEnvironmentBlock")
505
	procDestroyEnvironmentBlock                              = moduserenv.NewProc("DestroyEnvironmentBlock")
506
	procGetUserProfileDirectoryW                             = moduserenv.NewProc("GetUserProfileDirectoryW")
507
	procGetFileVersionInfoSizeW                              = modversion.NewProc("GetFileVersionInfoSizeW")
508
	procGetFileVersionInfoW                                  = modversion.NewProc("GetFileVersionInfoW")
509
	procVerQueryValueW                                       = modversion.NewProc("VerQueryValueW")
510
	proctimeBeginPeriod                                      = modwinmm.NewProc("timeBeginPeriod")
511
	proctimeEndPeriod                                        = modwinmm.NewProc("timeEndPeriod")
512
	procWinVerifyTrustEx                                     = modwintrust.NewProc("WinVerifyTrustEx")
513
	procFreeAddrInfoW                                        = modws2_32.NewProc("FreeAddrInfoW")
514
	procGetAddrInfoW                                         = modws2_32.NewProc("GetAddrInfoW")
515
	procWSACleanup                                           = modws2_32.NewProc("WSACleanup")
516
	procWSADuplicateSocketW                                  = modws2_32.NewProc("WSADuplicateSocketW")
517
	procWSAEnumProtocolsW                                    = modws2_32.NewProc("WSAEnumProtocolsW")
518
	procWSAGetOverlappedResult                               = modws2_32.NewProc("WSAGetOverlappedResult")
519
	procWSAIoctl                                             = modws2_32.NewProc("WSAIoctl")
520
	procWSALookupServiceBeginW                               = modws2_32.NewProc("WSALookupServiceBeginW")
521
	procWSALookupServiceEnd                                  = modws2_32.NewProc("WSALookupServiceEnd")
522
	procWSALookupServiceNextW                                = modws2_32.NewProc("WSALookupServiceNextW")
523
	procWSARecv                                              = modws2_32.NewProc("WSARecv")
524
	procWSARecvFrom                                          = modws2_32.NewProc("WSARecvFrom")
525
	procWSASend                                              = modws2_32.NewProc("WSASend")
526
	procWSASendTo                                            = modws2_32.NewProc("WSASendTo")
527
	procWSASocketW                                           = modws2_32.NewProc("WSASocketW")
528
	procWSAStartup                                           = modws2_32.NewProc("WSAStartup")
529
	procbind                                                 = modws2_32.NewProc("bind")
530
	procclosesocket                                          = modws2_32.NewProc("closesocket")
531
	procconnect                                              = modws2_32.NewProc("connect")
532
	procgethostbyname                                        = modws2_32.NewProc("gethostbyname")
533
	procgetpeername                                          = modws2_32.NewProc("getpeername")
534
	procgetprotobyname                                       = modws2_32.NewProc("getprotobyname")
535
	procgetservbyname                                        = modws2_32.NewProc("getservbyname")
536
	procgetsockname                                          = modws2_32.NewProc("getsockname")
537
	procgetsockopt                                           = modws2_32.NewProc("getsockopt")
538
	proclisten                                               = modws2_32.NewProc("listen")
539
	procntohs                                                = modws2_32.NewProc("ntohs")
540
	procrecvfrom                                             = modws2_32.NewProc("recvfrom")
541
	procsendto                                               = modws2_32.NewProc("sendto")
542
	procsetsockopt                                           = modws2_32.NewProc("setsockopt")
543
	procshutdown                                             = modws2_32.NewProc("shutdown")
544
	procsocket                                               = modws2_32.NewProc("socket")
545
	procWTSEnumerateSessionsW                                = modwtsapi32.NewProc("WTSEnumerateSessionsW")
546
	procWTSFreeMemory                                        = modwtsapi32.NewProc("WTSFreeMemory")
547
	procWTSQueryUserToken                                    = modwtsapi32.NewProc("WTSQueryUserToken")
548
)
549

550
func cm_Get_DevNode_Status(status *uint32, problemNumber *uint32, devInst DEVINST, flags uint32) (ret CONFIGRET) {
551
	r0, _, _ := syscall.SyscallN(procCM_Get_DevNode_Status.Addr(), uintptr(unsafe.Pointer(status)), uintptr(unsafe.Pointer(problemNumber)), uintptr(devInst), uintptr(flags))
552
	ret = CONFIGRET(r0)
553
	return
554
}
555

556
func cm_Get_Device_Interface_List(interfaceClass *GUID, deviceID *uint16, buffer *uint16, bufferLen uint32, flags uint32) (ret CONFIGRET) {
557
	r0, _, _ := syscall.SyscallN(procCM_Get_Device_Interface_ListW.Addr(), uintptr(unsafe.Pointer(interfaceClass)), uintptr(unsafe.Pointer(deviceID)), uintptr(unsafe.Pointer(buffer)), uintptr(bufferLen), uintptr(flags))
558
	ret = CONFIGRET(r0)
559
	return
560
}
561

562
func cm_Get_Device_Interface_List_Size(len *uint32, interfaceClass *GUID, deviceID *uint16, flags uint32) (ret CONFIGRET) {
563
	r0, _, _ := syscall.SyscallN(procCM_Get_Device_Interface_List_SizeW.Addr(), uintptr(unsafe.Pointer(len)), uintptr(unsafe.Pointer(interfaceClass)), uintptr(unsafe.Pointer(deviceID)), uintptr(flags))
564
	ret = CONFIGRET(r0)
565
	return
566
}
567

568
func cm_MapCrToWin32Err(configRet CONFIGRET, defaultWin32Error Errno) (ret Errno) {
569
	r0, _, _ := syscall.SyscallN(procCM_MapCrToWin32Err.Addr(), uintptr(configRet), uintptr(defaultWin32Error))
570
	ret = Errno(r0)
571
	return
572
}
573

574
func AdjustTokenGroups(token Token, resetToDefault bool, newstate *Tokengroups, buflen uint32, prevstate *Tokengroups, returnlen *uint32) (err error) {
575
	var _p0 uint32
576
	if resetToDefault {
577
		_p0 = 1
578
	}
579
	r1, _, e1 := syscall.SyscallN(procAdjustTokenGroups.Addr(), uintptr(token), uintptr(_p0), uintptr(unsafe.Pointer(newstate)), uintptr(buflen), uintptr(unsafe.Pointer(prevstate)), uintptr(unsafe.Pointer(returnlen)))
580
	if r1 == 0 {
581
		err = errnoErr(e1)
582
	}
583
	return
584
}
585

586
func AdjustTokenPrivileges(token Token, disableAllPrivileges bool, newstate *Tokenprivileges, buflen uint32, prevstate *Tokenprivileges, returnlen *uint32) (err error) {
587
	var _p0 uint32
588
	if disableAllPrivileges {
589
		_p0 = 1
590
	}
591
	r1, _, e1 := syscall.SyscallN(procAdjustTokenPrivileges.Addr(), uintptr(token), uintptr(_p0), uintptr(unsafe.Pointer(newstate)), uintptr(buflen), uintptr(unsafe.Pointer(prevstate)), uintptr(unsafe.Pointer(returnlen)))
592
	if r1 == 0 {
593
		err = errnoErr(e1)
594
	}
595
	return
596
}
597

598
func AllocateAndInitializeSid(identAuth *SidIdentifierAuthority, subAuth byte, subAuth0 uint32, subAuth1 uint32, subAuth2 uint32, subAuth3 uint32, subAuth4 uint32, subAuth5 uint32, subAuth6 uint32, subAuth7 uint32, sid **SID) (err error) {
599
	r1, _, e1 := syscall.SyscallN(procAllocateAndInitializeSid.Addr(), uintptr(unsafe.Pointer(identAuth)), uintptr(subAuth), uintptr(subAuth0), uintptr(subAuth1), uintptr(subAuth2), uintptr(subAuth3), uintptr(subAuth4), uintptr(subAuth5), uintptr(subAuth6), uintptr(subAuth7), uintptr(unsafe.Pointer(sid)))
600
	if r1 == 0 {
601
		err = errnoErr(e1)
602
	}
603
	return
604
}
605

606
func buildSecurityDescriptor(owner *TRUSTEE, group *TRUSTEE, countAccessEntries uint32, accessEntries *EXPLICIT_ACCESS, countAuditEntries uint32, auditEntries *EXPLICIT_ACCESS, oldSecurityDescriptor *SECURITY_DESCRIPTOR, sizeNewSecurityDescriptor *uint32, newSecurityDescriptor **SECURITY_DESCRIPTOR) (ret error) {
607
	r0, _, _ := syscall.SyscallN(procBuildSecurityDescriptorW.Addr(), uintptr(unsafe.Pointer(owner)), uintptr(unsafe.Pointer(group)), uintptr(countAccessEntries), uintptr(unsafe.Pointer(accessEntries)), uintptr(countAuditEntries), uintptr(unsafe.Pointer(auditEntries)), uintptr(unsafe.Pointer(oldSecurityDescriptor)), uintptr(unsafe.Pointer(sizeNewSecurityDescriptor)), uintptr(unsafe.Pointer(newSecurityDescriptor)))
608
	if r0 != 0 {
609
		ret = syscall.Errno(r0)
610
	}
611
	return
612
}
613

614
func ChangeServiceConfig2(service Handle, infoLevel uint32, info *byte) (err error) {
615
	r1, _, e1 := syscall.SyscallN(procChangeServiceConfig2W.Addr(), uintptr(service), uintptr(infoLevel), uintptr(unsafe.Pointer(info)))
616
	if r1 == 0 {
617
		err = errnoErr(e1)
618
	}
619
	return
620
}
621

622
func ChangeServiceConfig(service Handle, serviceType uint32, startType uint32, errorControl uint32, binaryPathName *uint16, loadOrderGroup *uint16, tagId *uint32, dependencies *uint16, serviceStartName *uint16, password *uint16, displayName *uint16) (err error) {
623
	r1, _, e1 := syscall.SyscallN(procChangeServiceConfigW.Addr(), uintptr(service), uintptr(serviceType), uintptr(startType), uintptr(errorControl), uintptr(unsafe.Pointer(binaryPathName)), uintptr(unsafe.Pointer(loadOrderGroup)), uintptr(unsafe.Pointer(tagId)), uintptr(unsafe.Pointer(dependencies)), uintptr(unsafe.Pointer(serviceStartName)), uintptr(unsafe.Pointer(password)), uintptr(unsafe.Pointer(displayName)))
624
	if r1 == 0 {
625
		err = errnoErr(e1)
626
	}
627
	return
628
}
629

630
func checkTokenMembership(tokenHandle Token, sidToCheck *SID, isMember *int32) (err error) {
631
	r1, _, e1 := syscall.SyscallN(procCheckTokenMembership.Addr(), uintptr(tokenHandle), uintptr(unsafe.Pointer(sidToCheck)), uintptr(unsafe.Pointer(isMember)))
632
	if r1 == 0 {
633
		err = errnoErr(e1)
634
	}
635
	return
636
}
637

638
func CloseServiceHandle(handle Handle) (err error) {
639
	r1, _, e1 := syscall.SyscallN(procCloseServiceHandle.Addr(), uintptr(handle))
640
	if r1 == 0 {
641
		err = errnoErr(e1)
642
	}
643
	return
644
}
645

646
func ControlService(service Handle, control uint32, status *SERVICE_STATUS) (err error) {
647
	r1, _, e1 := syscall.SyscallN(procControlService.Addr(), uintptr(service), uintptr(control), uintptr(unsafe.Pointer(status)))
648
	if r1 == 0 {
649
		err = errnoErr(e1)
650
	}
651
	return
652
}
653

654
func convertSecurityDescriptorToStringSecurityDescriptor(sd *SECURITY_DESCRIPTOR, revision uint32, securityInformation SECURITY_INFORMATION, str **uint16, strLen *uint32) (err error) {
655
	r1, _, e1 := syscall.SyscallN(procConvertSecurityDescriptorToStringSecurityDescriptorW.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(revision), uintptr(securityInformation), uintptr(unsafe.Pointer(str)), uintptr(unsafe.Pointer(strLen)))
656
	if r1 == 0 {
657
		err = errnoErr(e1)
658
	}
659
	return
660
}
661

662
func ConvertSidToStringSid(sid *SID, stringSid **uint16) (err error) {
663
	r1, _, e1 := syscall.SyscallN(procConvertSidToStringSidW.Addr(), uintptr(unsafe.Pointer(sid)), uintptr(unsafe.Pointer(stringSid)))
664
	if r1 == 0 {
665
		err = errnoErr(e1)
666
	}
667
	return
668
}
669

670
func convertStringSecurityDescriptorToSecurityDescriptor(str string, revision uint32, sd **SECURITY_DESCRIPTOR, size *uint32) (err error) {
671
	var _p0 *uint16
672
	_p0, err = syscall.UTF16PtrFromString(str)
673
	if err != nil {
674
		return
675
	}
676
	return _convertStringSecurityDescriptorToSecurityDescriptor(_p0, revision, sd, size)
677
}
678

679
func _convertStringSecurityDescriptorToSecurityDescriptor(str *uint16, revision uint32, sd **SECURITY_DESCRIPTOR, size *uint32) (err error) {
680
	r1, _, e1 := syscall.SyscallN(procConvertStringSecurityDescriptorToSecurityDescriptorW.Addr(), uintptr(unsafe.Pointer(str)), uintptr(revision), uintptr(unsafe.Pointer(sd)), uintptr(unsafe.Pointer(size)))
681
	if r1 == 0 {
682
		err = errnoErr(e1)
683
	}
684
	return
685
}
686

687
func ConvertStringSidToSid(stringSid *uint16, sid **SID) (err error) {
688
	r1, _, e1 := syscall.SyscallN(procConvertStringSidToSidW.Addr(), uintptr(unsafe.Pointer(stringSid)), uintptr(unsafe.Pointer(sid)))
689
	if r1 == 0 {
690
		err = errnoErr(e1)
691
	}
692
	return
693
}
694

695
func CopySid(destSidLen uint32, destSid *SID, srcSid *SID) (err error) {
696
	r1, _, e1 := syscall.SyscallN(procCopySid.Addr(), uintptr(destSidLen), uintptr(unsafe.Pointer(destSid)), uintptr(unsafe.Pointer(srcSid)))
697
	if r1 == 0 {
698
		err = errnoErr(e1)
699
	}
700
	return
701
}
702

703
func CreateProcessAsUser(token Token, appName *uint16, commandLine *uint16, procSecurity *SecurityAttributes, threadSecurity *SecurityAttributes, inheritHandles bool, creationFlags uint32, env *uint16, currentDir *uint16, startupInfo *StartupInfo, outProcInfo *ProcessInformation) (err error) {
704
	var _p0 uint32
705
	if inheritHandles {
706
		_p0 = 1
707
	}
708
	r1, _, e1 := syscall.SyscallN(procCreateProcessAsUserW.Addr(), uintptr(token), uintptr(unsafe.Pointer(appName)), uintptr(unsafe.Pointer(commandLine)), uintptr(unsafe.Pointer(procSecurity)), uintptr(unsafe.Pointer(threadSecurity)), uintptr(_p0), uintptr(creationFlags), uintptr(unsafe.Pointer(env)), uintptr(unsafe.Pointer(currentDir)), uintptr(unsafe.Pointer(startupInfo)), uintptr(unsafe.Pointer(outProcInfo)))
709
	if r1 == 0 {
710
		err = errnoErr(e1)
711
	}
712
	return
713
}
714

715
func CreateService(mgr Handle, serviceName *uint16, displayName *uint16, access uint32, srvType uint32, startType uint32, errCtl uint32, pathName *uint16, loadOrderGroup *uint16, tagId *uint32, dependencies *uint16, serviceStartName *uint16, password *uint16) (handle Handle, err error) {
716
	r0, _, e1 := syscall.SyscallN(procCreateServiceW.Addr(), uintptr(mgr), uintptr(unsafe.Pointer(serviceName)), uintptr(unsafe.Pointer(displayName)), uintptr(access), uintptr(srvType), uintptr(startType), uintptr(errCtl), uintptr(unsafe.Pointer(pathName)), uintptr(unsafe.Pointer(loadOrderGroup)), uintptr(unsafe.Pointer(tagId)), uintptr(unsafe.Pointer(dependencies)), uintptr(unsafe.Pointer(serviceStartName)), uintptr(unsafe.Pointer(password)))
717
	handle = Handle(r0)
718
	if handle == 0 {
719
		err = errnoErr(e1)
720
	}
721
	return
722
}
723

724
func createWellKnownSid(sidType WELL_KNOWN_SID_TYPE, domainSid *SID, sid *SID, sizeSid *uint32) (err error) {
725
	r1, _, e1 := syscall.SyscallN(procCreateWellKnownSid.Addr(), uintptr(sidType), uintptr(unsafe.Pointer(domainSid)), uintptr(unsafe.Pointer(sid)), uintptr(unsafe.Pointer(sizeSid)))
726
	if r1 == 0 {
727
		err = errnoErr(e1)
728
	}
729
	return
730
}
731

732
func CryptAcquireContext(provhandle *Handle, container *uint16, provider *uint16, provtype uint32, flags uint32) (err error) {
733
	r1, _, e1 := syscall.SyscallN(procCryptAcquireContextW.Addr(), uintptr(unsafe.Pointer(provhandle)), uintptr(unsafe.Pointer(container)), uintptr(unsafe.Pointer(provider)), uintptr(provtype), uintptr(flags))
734
	if r1 == 0 {
735
		err = errnoErr(e1)
736
	}
737
	return
738
}
739

740
func CryptGenRandom(provhandle Handle, buflen uint32, buf *byte) (err error) {
741
	r1, _, e1 := syscall.SyscallN(procCryptGenRandom.Addr(), uintptr(provhandle), uintptr(buflen), uintptr(unsafe.Pointer(buf)))
742
	if r1 == 0 {
743
		err = errnoErr(e1)
744
	}
745
	return
746
}
747

748
func CryptReleaseContext(provhandle Handle, flags uint32) (err error) {
749
	r1, _, e1 := syscall.SyscallN(procCryptReleaseContext.Addr(), uintptr(provhandle), uintptr(flags))
750
	if r1 == 0 {
751
		err = errnoErr(e1)
752
	}
753
	return
754
}
755

756
func DeleteService(service Handle) (err error) {
757
	r1, _, e1 := syscall.SyscallN(procDeleteService.Addr(), uintptr(service))
758
	if r1 == 0 {
759
		err = errnoErr(e1)
760
	}
761
	return
762
}
763

764
func DeregisterEventSource(handle Handle) (err error) {
765
	r1, _, e1 := syscall.SyscallN(procDeregisterEventSource.Addr(), uintptr(handle))
766
	if r1 == 0 {
767
		err = errnoErr(e1)
768
	}
769
	return
770
}
771

772
func DuplicateTokenEx(existingToken Token, desiredAccess uint32, tokenAttributes *SecurityAttributes, impersonationLevel uint32, tokenType uint32, newToken *Token) (err error) {
773
	r1, _, e1 := syscall.SyscallN(procDuplicateTokenEx.Addr(), uintptr(existingToken), uintptr(desiredAccess), uintptr(unsafe.Pointer(tokenAttributes)), uintptr(impersonationLevel), uintptr(tokenType), uintptr(unsafe.Pointer(newToken)))
774
	if r1 == 0 {
775
		err = errnoErr(e1)
776
	}
777
	return
778
}
779

780
func EnumDependentServices(service Handle, activityState uint32, services *ENUM_SERVICE_STATUS, buffSize uint32, bytesNeeded *uint32, servicesReturned *uint32) (err error) {
781
	r1, _, e1 := syscall.SyscallN(procEnumDependentServicesW.Addr(), uintptr(service), uintptr(activityState), uintptr(unsafe.Pointer(services)), uintptr(buffSize), uintptr(unsafe.Pointer(bytesNeeded)), uintptr(unsafe.Pointer(servicesReturned)))
782
	if r1 == 0 {
783
		err = errnoErr(e1)
784
	}
785
	return
786
}
787

788
func EnumServicesStatusEx(mgr Handle, infoLevel uint32, serviceType uint32, serviceState uint32, services *byte, bufSize uint32, bytesNeeded *uint32, servicesReturned *uint32, resumeHandle *uint32, groupName *uint16) (err error) {
789
	r1, _, e1 := syscall.SyscallN(procEnumServicesStatusExW.Addr(), uintptr(mgr), uintptr(infoLevel), uintptr(serviceType), uintptr(serviceState), uintptr(unsafe.Pointer(services)), uintptr(bufSize), uintptr(unsafe.Pointer(bytesNeeded)), uintptr(unsafe.Pointer(servicesReturned)), uintptr(unsafe.Pointer(resumeHandle)), uintptr(unsafe.Pointer(groupName)))
790
	if r1 == 0 {
791
		err = errnoErr(e1)
792
	}
793
	return
794
}
795

796
func EqualSid(sid1 *SID, sid2 *SID) (isEqual bool) {
797
	r0, _, _ := syscall.SyscallN(procEqualSid.Addr(), uintptr(unsafe.Pointer(sid1)), uintptr(unsafe.Pointer(sid2)))
798
	isEqual = r0 != 0
799
	return
800
}
801

802
func FreeSid(sid *SID) (err error) {
803
	r1, _, e1 := syscall.SyscallN(procFreeSid.Addr(), uintptr(unsafe.Pointer(sid)))
804
	if r1 != 0 {
805
		err = errnoErr(e1)
806
	}
807
	return
808
}
809

810
func GetAce(acl *ACL, aceIndex uint32, pAce **ACCESS_ALLOWED_ACE) (err error) {
811
	r1, _, e1 := syscall.SyscallN(procGetAce.Addr(), uintptr(unsafe.Pointer(acl)), uintptr(aceIndex), uintptr(unsafe.Pointer(pAce)))
812
	if r1 == 0 {
813
		err = errnoErr(e1)
814
	}
815
	return
816
}
817

818
func GetLengthSid(sid *SID) (len uint32) {
819
	r0, _, _ := syscall.SyscallN(procGetLengthSid.Addr(), uintptr(unsafe.Pointer(sid)))
820
	len = uint32(r0)
821
	return
822
}
823

824
func getNamedSecurityInfo(objectName string, objectType SE_OBJECT_TYPE, securityInformation SECURITY_INFORMATION, owner **SID, group **SID, dacl **ACL, sacl **ACL, sd **SECURITY_DESCRIPTOR) (ret error) {
825
	var _p0 *uint16
826
	_p0, ret = syscall.UTF16PtrFromString(objectName)
827
	if ret != nil {
828
		return
829
	}
830
	return _getNamedSecurityInfo(_p0, objectType, securityInformation, owner, group, dacl, sacl, sd)
831
}
832

833
func _getNamedSecurityInfo(objectName *uint16, objectType SE_OBJECT_TYPE, securityInformation SECURITY_INFORMATION, owner **SID, group **SID, dacl **ACL, sacl **ACL, sd **SECURITY_DESCRIPTOR) (ret error) {
834
	r0, _, _ := syscall.SyscallN(procGetNamedSecurityInfoW.Addr(), uintptr(unsafe.Pointer(objectName)), uintptr(objectType), uintptr(securityInformation), uintptr(unsafe.Pointer(owner)), uintptr(unsafe.Pointer(group)), uintptr(unsafe.Pointer(dacl)), uintptr(unsafe.Pointer(sacl)), uintptr(unsafe.Pointer(sd)))
835
	if r0 != 0 {
836
		ret = syscall.Errno(r0)
837
	}
838
	return
839
}
840

841
func getSecurityDescriptorControl(sd *SECURITY_DESCRIPTOR, control *SECURITY_DESCRIPTOR_CONTROL, revision *uint32) (err error) {
842
	r1, _, e1 := syscall.SyscallN(procGetSecurityDescriptorControl.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(unsafe.Pointer(control)), uintptr(unsafe.Pointer(revision)))
843
	if r1 == 0 {
844
		err = errnoErr(e1)
845
	}
846
	return
847
}
848

849
func getSecurityDescriptorDacl(sd *SECURITY_DESCRIPTOR, daclPresent *bool, dacl **ACL, daclDefaulted *bool) (err error) {
850
	var _p0 uint32
851
	if *daclPresent {
852
		_p0 = 1
853
	}
854
	var _p1 uint32
855
	if *daclDefaulted {
856
		_p1 = 1
857
	}
858
	r1, _, e1 := syscall.SyscallN(procGetSecurityDescriptorDacl.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(unsafe.Pointer(&_p0)), uintptr(unsafe.Pointer(dacl)), uintptr(unsafe.Pointer(&_p1)))
859
	*daclPresent = _p0 != 0
860
	*daclDefaulted = _p1 != 0
861
	if r1 == 0 {
862
		err = errnoErr(e1)
863
	}
864
	return
865
}
866

867
func getSecurityDescriptorGroup(sd *SECURITY_DESCRIPTOR, group **SID, groupDefaulted *bool) (err error) {
868
	var _p0 uint32
869
	if *groupDefaulted {
870
		_p0 = 1
871
	}
872
	r1, _, e1 := syscall.SyscallN(procGetSecurityDescriptorGroup.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(unsafe.Pointer(group)), uintptr(unsafe.Pointer(&_p0)))
873
	*groupDefaulted = _p0 != 0
874
	if r1 == 0 {
875
		err = errnoErr(e1)
876
	}
877
	return
878
}
879

880
func getSecurityDescriptorLength(sd *SECURITY_DESCRIPTOR) (len uint32) {
881
	r0, _, _ := syscall.SyscallN(procGetSecurityDescriptorLength.Addr(), uintptr(unsafe.Pointer(sd)))
882
	len = uint32(r0)
883
	return
884
}
885

886
func getSecurityDescriptorOwner(sd *SECURITY_DESCRIPTOR, owner **SID, ownerDefaulted *bool) (err error) {
887
	var _p0 uint32
888
	if *ownerDefaulted {
889
		_p0 = 1
890
	}
891
	r1, _, e1 := syscall.SyscallN(procGetSecurityDescriptorOwner.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(unsafe.Pointer(owner)), uintptr(unsafe.Pointer(&_p0)))
892
	*ownerDefaulted = _p0 != 0
893
	if r1 == 0 {
894
		err = errnoErr(e1)
895
	}
896
	return
897
}
898

899
func getSecurityDescriptorRMControl(sd *SECURITY_DESCRIPTOR, rmControl *uint8) (ret error) {
900
	r0, _, _ := syscall.SyscallN(procGetSecurityDescriptorRMControl.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(unsafe.Pointer(rmControl)))
901
	if r0 != 0 {
902
		ret = syscall.Errno(r0)
903
	}
904
	return
905
}
906

907
func getSecurityDescriptorSacl(sd *SECURITY_DESCRIPTOR, saclPresent *bool, sacl **ACL, saclDefaulted *bool) (err error) {
908
	var _p0 uint32
909
	if *saclPresent {
910
		_p0 = 1
911
	}
912
	var _p1 uint32
913
	if *saclDefaulted {
914
		_p1 = 1
915
	}
916
	r1, _, e1 := syscall.SyscallN(procGetSecurityDescriptorSacl.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(unsafe.Pointer(&_p0)), uintptr(unsafe.Pointer(sacl)), uintptr(unsafe.Pointer(&_p1)))
917
	*saclPresent = _p0 != 0
918
	*saclDefaulted = _p1 != 0
919
	if r1 == 0 {
920
		err = errnoErr(e1)
921
	}
922
	return
923
}
924

925
func getSecurityInfo(handle Handle, objectType SE_OBJECT_TYPE, securityInformation SECURITY_INFORMATION, owner **SID, group **SID, dacl **ACL, sacl **ACL, sd **SECURITY_DESCRIPTOR) (ret error) {
926
	r0, _, _ := syscall.SyscallN(procGetSecurityInfo.Addr(), uintptr(handle), uintptr(objectType), uintptr(securityInformation), uintptr(unsafe.Pointer(owner)), uintptr(unsafe.Pointer(group)), uintptr(unsafe.Pointer(dacl)), uintptr(unsafe.Pointer(sacl)), uintptr(unsafe.Pointer(sd)))
927
	if r0 != 0 {
928
		ret = syscall.Errno(r0)
929
	}
930
	return
931
}
932

933
func getSidIdentifierAuthority(sid *SID) (authority *SidIdentifierAuthority) {
934
	r0, _, _ := syscall.SyscallN(procGetSidIdentifierAuthority.Addr(), uintptr(unsafe.Pointer(sid)))
935
	authority = (*SidIdentifierAuthority)(unsafe.Pointer(r0))
936
	return
937
}
938

939
func getSidSubAuthority(sid *SID, index uint32) (subAuthority *uint32) {
940
	r0, _, _ := syscall.SyscallN(procGetSidSubAuthority.Addr(), uintptr(unsafe.Pointer(sid)), uintptr(index))
941
	subAuthority = (*uint32)(unsafe.Pointer(r0))
942
	return
943
}
944

945
func getSidSubAuthorityCount(sid *SID) (count *uint8) {
946
	r0, _, _ := syscall.SyscallN(procGetSidSubAuthorityCount.Addr(), uintptr(unsafe.Pointer(sid)))
947
	count = (*uint8)(unsafe.Pointer(r0))
948
	return
949
}
950

951
func GetTokenInformation(token Token, infoClass uint32, info *byte, infoLen uint32, returnedLen *uint32) (err error) {
952
	r1, _, e1 := syscall.SyscallN(procGetTokenInformation.Addr(), uintptr(token), uintptr(infoClass), uintptr(unsafe.Pointer(info)), uintptr(infoLen), uintptr(unsafe.Pointer(returnedLen)))
953
	if r1 == 0 {
954
		err = errnoErr(e1)
955
	}
956
	return
957
}
958

959
func ImpersonateSelf(impersonationlevel uint32) (err error) {
960
	r1, _, e1 := syscall.SyscallN(procImpersonateSelf.Addr(), uintptr(impersonationlevel))
961
	if r1 == 0 {
962
		err = errnoErr(e1)
963
	}
964
	return
965
}
966

967
func initializeSecurityDescriptor(absoluteSD *SECURITY_DESCRIPTOR, revision uint32) (err error) {
968
	r1, _, e1 := syscall.SyscallN(procInitializeSecurityDescriptor.Addr(), uintptr(unsafe.Pointer(absoluteSD)), uintptr(revision))
969
	if r1 == 0 {
970
		err = errnoErr(e1)
971
	}
972
	return
973
}
974

975
func InitiateSystemShutdownEx(machineName *uint16, message *uint16, timeout uint32, forceAppsClosed bool, rebootAfterShutdown bool, reason uint32) (err error) {
976
	var _p0 uint32
977
	if forceAppsClosed {
978
		_p0 = 1
979
	}
980
	var _p1 uint32
981
	if rebootAfterShutdown {
982
		_p1 = 1
983
	}
984
	r1, _, e1 := syscall.SyscallN(procInitiateSystemShutdownExW.Addr(), uintptr(unsafe.Pointer(machineName)), uintptr(unsafe.Pointer(message)), uintptr(timeout), uintptr(_p0), uintptr(_p1), uintptr(reason))
985
	if r1 == 0 {
986
		err = errnoErr(e1)
987
	}
988
	return
989
}
990

991
func isTokenRestricted(tokenHandle Token) (ret bool, err error) {
992
	r0, _, e1 := syscall.SyscallN(procIsTokenRestricted.Addr(), uintptr(tokenHandle))
993
	ret = r0 != 0
994
	if !ret {
995
		err = errnoErr(e1)
996
	}
997
	return
998
}
999

1000
func isValidSecurityDescriptor(sd *SECURITY_DESCRIPTOR) (isValid bool) {
1001
	r0, _, _ := syscall.SyscallN(procIsValidSecurityDescriptor.Addr(), uintptr(unsafe.Pointer(sd)))
1002
	isValid = r0 != 0
1003
	return
1004
}
1005

1006
func isValidSid(sid *SID) (isValid bool) {
1007
	r0, _, _ := syscall.SyscallN(procIsValidSid.Addr(), uintptr(unsafe.Pointer(sid)))
1008
	isValid = r0 != 0
1009
	return
1010
}
1011

1012
func isWellKnownSid(sid *SID, sidType WELL_KNOWN_SID_TYPE) (isWellKnown bool) {
1013
	r0, _, _ := syscall.SyscallN(procIsWellKnownSid.Addr(), uintptr(unsafe.Pointer(sid)), uintptr(sidType))
1014
	isWellKnown = r0 != 0
1015
	return
1016
}
1017

1018
func LookupAccountName(systemName *uint16, accountName *uint16, sid *SID, sidLen *uint32, refdDomainName *uint16, refdDomainNameLen *uint32, use *uint32) (err error) {
1019
	r1, _, e1 := syscall.SyscallN(procLookupAccountNameW.Addr(), uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(accountName)), uintptr(unsafe.Pointer(sid)), uintptr(unsafe.Pointer(sidLen)), uintptr(unsafe.Pointer(refdDomainName)), uintptr(unsafe.Pointer(refdDomainNameLen)), uintptr(unsafe.Pointer(use)))
1020
	if r1 == 0 {
1021
		err = errnoErr(e1)
1022
	}
1023
	return
1024
}
1025

1026
func LookupAccountSid(systemName *uint16, sid *SID, name *uint16, nameLen *uint32, refdDomainName *uint16, refdDomainNameLen *uint32, use *uint32) (err error) {
1027
	r1, _, e1 := syscall.SyscallN(procLookupAccountSidW.Addr(), uintptr(unsafe.Pointer(systemName)), uintptr(unsafe.Pointer(sid)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(nameLen)), uintptr(unsafe.Pointer(refdDomainName)), uintptr(unsafe.Pointer(refdDomainNameLen)), uintptr(unsafe.Pointer(use)))
1028
	if r1 == 0 {
1029
		err = errnoErr(e1)
1030
	}
1031
	return
1032
}
1033

1034
func LookupPrivilegeValue(systemname *uint16, name *uint16, luid *LUID) (err error) {
1035
	r1, _, e1 := syscall.SyscallN(procLookupPrivilegeValueW.Addr(), uintptr(unsafe.Pointer(systemname)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(luid)))
1036
	if r1 == 0 {
1037
		err = errnoErr(e1)
1038
	}
1039
	return
1040
}
1041

1042
func makeAbsoluteSD(selfRelativeSD *SECURITY_DESCRIPTOR, absoluteSD *SECURITY_DESCRIPTOR, absoluteSDSize *uint32, dacl *ACL, daclSize *uint32, sacl *ACL, saclSize *uint32, owner *SID, ownerSize *uint32, group *SID, groupSize *uint32) (err error) {
1043
	r1, _, e1 := syscall.SyscallN(procMakeAbsoluteSD.Addr(), uintptr(unsafe.Pointer(selfRelativeSD)), uintptr(unsafe.Pointer(absoluteSD)), uintptr(unsafe.Pointer(absoluteSDSize)), uintptr(unsafe.Pointer(dacl)), uintptr(unsafe.Pointer(daclSize)), uintptr(unsafe.Pointer(sacl)), uintptr(unsafe.Pointer(saclSize)), uintptr(unsafe.Pointer(owner)), uintptr(unsafe.Pointer(ownerSize)), uintptr(unsafe.Pointer(group)), uintptr(unsafe.Pointer(groupSize)))
1044
	if r1 == 0 {
1045
		err = errnoErr(e1)
1046
	}
1047
	return
1048
}
1049

1050
func makeSelfRelativeSD(absoluteSD *SECURITY_DESCRIPTOR, selfRelativeSD *SECURITY_DESCRIPTOR, selfRelativeSDSize *uint32) (err error) {
1051
	r1, _, e1 := syscall.SyscallN(procMakeSelfRelativeSD.Addr(), uintptr(unsafe.Pointer(absoluteSD)), uintptr(unsafe.Pointer(selfRelativeSD)), uintptr(unsafe.Pointer(selfRelativeSDSize)))
1052
	if r1 == 0 {
1053
		err = errnoErr(e1)
1054
	}
1055
	return
1056
}
1057

1058
func NotifyServiceStatusChange(service Handle, notifyMask uint32, notifier *SERVICE_NOTIFY) (ret error) {
1059
	r0, _, _ := syscall.SyscallN(procNotifyServiceStatusChangeW.Addr(), uintptr(service), uintptr(notifyMask), uintptr(unsafe.Pointer(notifier)))
1060
	if r0 != 0 {
1061
		ret = syscall.Errno(r0)
1062
	}
1063
	return
1064
}
1065

1066
func OpenProcessToken(process Handle, access uint32, token *Token) (err error) {
1067
	r1, _, e1 := syscall.SyscallN(procOpenProcessToken.Addr(), uintptr(process), uintptr(access), uintptr(unsafe.Pointer(token)))
1068
	if r1 == 0 {
1069
		err = errnoErr(e1)
1070
	}
1071
	return
1072
}
1073

1074
func OpenSCManager(machineName *uint16, databaseName *uint16, access uint32) (handle Handle, err error) {
1075
	r0, _, e1 := syscall.SyscallN(procOpenSCManagerW.Addr(), uintptr(unsafe.Pointer(machineName)), uintptr(unsafe.Pointer(databaseName)), uintptr(access))
1076
	handle = Handle(r0)
1077
	if handle == 0 {
1078
		err = errnoErr(e1)
1079
	}
1080
	return
1081
}
1082

1083
func OpenService(mgr Handle, serviceName *uint16, access uint32) (handle Handle, err error) {
1084
	r0, _, e1 := syscall.SyscallN(procOpenServiceW.Addr(), uintptr(mgr), uintptr(unsafe.Pointer(serviceName)), uintptr(access))
1085
	handle = Handle(r0)
1086
	if handle == 0 {
1087
		err = errnoErr(e1)
1088
	}
1089
	return
1090
}
1091

1092
func OpenThreadToken(thread Handle, access uint32, openAsSelf bool, token *Token) (err error) {
1093
	var _p0 uint32
1094
	if openAsSelf {
1095
		_p0 = 1
1096
	}
1097
	r1, _, e1 := syscall.SyscallN(procOpenThreadToken.Addr(), uintptr(thread), uintptr(access), uintptr(_p0), uintptr(unsafe.Pointer(token)))
1098
	if r1 == 0 {
1099
		err = errnoErr(e1)
1100
	}
1101
	return
1102
}
1103

1104
func QueryServiceConfig2(service Handle, infoLevel uint32, buff *byte, buffSize uint32, bytesNeeded *uint32) (err error) {
1105
	r1, _, e1 := syscall.SyscallN(procQueryServiceConfig2W.Addr(), uintptr(service), uintptr(infoLevel), uintptr(unsafe.Pointer(buff)), uintptr(buffSize), uintptr(unsafe.Pointer(bytesNeeded)))
1106
	if r1 == 0 {
1107
		err = errnoErr(e1)
1108
	}
1109
	return
1110
}
1111

1112
func QueryServiceConfig(service Handle, serviceConfig *QUERY_SERVICE_CONFIG, bufSize uint32, bytesNeeded *uint32) (err error) {
1113
	r1, _, e1 := syscall.SyscallN(procQueryServiceConfigW.Addr(), uintptr(service), uintptr(unsafe.Pointer(serviceConfig)), uintptr(bufSize), uintptr(unsafe.Pointer(bytesNeeded)))
1114
	if r1 == 0 {
1115
		err = errnoErr(e1)
1116
	}
1117
	return
1118
}
1119

1120
func QueryServiceDynamicInformation(service Handle, infoLevel uint32, dynamicInfo unsafe.Pointer) (err error) {
1121
	err = procQueryServiceDynamicInformation.Find()
1122
	if err != nil {
1123
		return
1124
	}
1125
	r1, _, e1 := syscall.SyscallN(procQueryServiceDynamicInformation.Addr(), uintptr(service), uintptr(infoLevel), uintptr(dynamicInfo))
1126
	if r1 == 0 {
1127
		err = errnoErr(e1)
1128
	}
1129
	return
1130
}
1131

1132
func QueryServiceLockStatus(mgr Handle, lockStatus *QUERY_SERVICE_LOCK_STATUS, bufSize uint32, bytesNeeded *uint32) (err error) {
1133
	r1, _, e1 := syscall.SyscallN(procQueryServiceLockStatusW.Addr(), uintptr(mgr), uintptr(unsafe.Pointer(lockStatus)), uintptr(bufSize), uintptr(unsafe.Pointer(bytesNeeded)))
1134
	if r1 == 0 {
1135
		err = errnoErr(e1)
1136
	}
1137
	return
1138
}
1139

1140
func QueryServiceStatus(service Handle, status *SERVICE_STATUS) (err error) {
1141
	r1, _, e1 := syscall.SyscallN(procQueryServiceStatus.Addr(), uintptr(service), uintptr(unsafe.Pointer(status)))
1142
	if r1 == 0 {
1143
		err = errnoErr(e1)
1144
	}
1145
	return
1146
}
1147

1148
func QueryServiceStatusEx(service Handle, infoLevel uint32, buff *byte, buffSize uint32, bytesNeeded *uint32) (err error) {
1149
	r1, _, e1 := syscall.SyscallN(procQueryServiceStatusEx.Addr(), uintptr(service), uintptr(infoLevel), uintptr(unsafe.Pointer(buff)), uintptr(buffSize), uintptr(unsafe.Pointer(bytesNeeded)))
1150
	if r1 == 0 {
1151
		err = errnoErr(e1)
1152
	}
1153
	return
1154
}
1155

1156
func RegCloseKey(key Handle) (regerrno error) {
1157
	r0, _, _ := syscall.SyscallN(procRegCloseKey.Addr(), uintptr(key))
1158
	if r0 != 0 {
1159
		regerrno = syscall.Errno(r0)
1160
	}
1161
	return
1162
}
1163

1164
func RegEnumKeyEx(key Handle, index uint32, name *uint16, nameLen *uint32, reserved *uint32, class *uint16, classLen *uint32, lastWriteTime *Filetime) (regerrno error) {
1165
	r0, _, _ := syscall.SyscallN(procRegEnumKeyExW.Addr(), uintptr(key), uintptr(index), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(nameLen)), uintptr(unsafe.Pointer(reserved)), uintptr(unsafe.Pointer(class)), uintptr(unsafe.Pointer(classLen)), uintptr(unsafe.Pointer(lastWriteTime)))
1166
	if r0 != 0 {
1167
		regerrno = syscall.Errno(r0)
1168
	}
1169
	return
1170
}
1171

1172
func RegNotifyChangeKeyValue(key Handle, watchSubtree bool, notifyFilter uint32, event Handle, asynchronous bool) (regerrno error) {
1173
	var _p0 uint32
1174
	if watchSubtree {
1175
		_p0 = 1
1176
	}
1177
	var _p1 uint32
1178
	if asynchronous {
1179
		_p1 = 1
1180
	}
1181
	r0, _, _ := syscall.SyscallN(procRegNotifyChangeKeyValue.Addr(), uintptr(key), uintptr(_p0), uintptr(notifyFilter), uintptr(event), uintptr(_p1))
1182
	if r0 != 0 {
1183
		regerrno = syscall.Errno(r0)
1184
	}
1185
	return
1186
}
1187

1188
func RegOpenKeyEx(key Handle, subkey *uint16, options uint32, desiredAccess uint32, result *Handle) (regerrno error) {
1189
	r0, _, _ := syscall.SyscallN(procRegOpenKeyExW.Addr(), uintptr(key), uintptr(unsafe.Pointer(subkey)), uintptr(options), uintptr(desiredAccess), uintptr(unsafe.Pointer(result)))
1190
	if r0 != 0 {
1191
		regerrno = syscall.Errno(r0)
1192
	}
1193
	return
1194
}
1195

1196
func RegQueryInfoKey(key Handle, class *uint16, classLen *uint32, reserved *uint32, subkeysLen *uint32, maxSubkeyLen *uint32, maxClassLen *uint32, valuesLen *uint32, maxValueNameLen *uint32, maxValueLen *uint32, saLen *uint32, lastWriteTime *Filetime) (regerrno error) {
1197
	r0, _, _ := syscall.SyscallN(procRegQueryInfoKeyW.Addr(), uintptr(key), uintptr(unsafe.Pointer(class)), uintptr(unsafe.Pointer(classLen)), uintptr(unsafe.Pointer(reserved)), uintptr(unsafe.Pointer(subkeysLen)), uintptr(unsafe.Pointer(maxSubkeyLen)), uintptr(unsafe.Pointer(maxClassLen)), uintptr(unsafe.Pointer(valuesLen)), uintptr(unsafe.Pointer(maxValueNameLen)), uintptr(unsafe.Pointer(maxValueLen)), uintptr(unsafe.Pointer(saLen)), uintptr(unsafe.Pointer(lastWriteTime)))
1198
	if r0 != 0 {
1199
		regerrno = syscall.Errno(r0)
1200
	}
1201
	return
1202
}
1203

1204
func RegQueryValueEx(key Handle, name *uint16, reserved *uint32, valtype *uint32, buf *byte, buflen *uint32) (regerrno error) {
1205
	r0, _, _ := syscall.SyscallN(procRegQueryValueExW.Addr(), uintptr(key), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(reserved)), uintptr(unsafe.Pointer(valtype)), uintptr(unsafe.Pointer(buf)), uintptr(unsafe.Pointer(buflen)))
1206
	if r0 != 0 {
1207
		regerrno = syscall.Errno(r0)
1208
	}
1209
	return
1210
}
1211

1212
func RegisterEventSource(uncServerName *uint16, sourceName *uint16) (handle Handle, err error) {
1213
	r0, _, e1 := syscall.SyscallN(procRegisterEventSourceW.Addr(), uintptr(unsafe.Pointer(uncServerName)), uintptr(unsafe.Pointer(sourceName)))
1214
	handle = Handle(r0)
1215
	if handle == 0 {
1216
		err = errnoErr(e1)
1217
	}
1218
	return
1219
}
1220

1221
func RegisterServiceCtrlHandlerEx(serviceName *uint16, handlerProc uintptr, context uintptr) (handle Handle, err error) {
1222
	r0, _, e1 := syscall.SyscallN(procRegisterServiceCtrlHandlerExW.Addr(), uintptr(unsafe.Pointer(serviceName)), uintptr(handlerProc), uintptr(context))
1223
	handle = Handle(r0)
1224
	if handle == 0 {
1225
		err = errnoErr(e1)
1226
	}
1227
	return
1228
}
1229

1230
func ReportEvent(log Handle, etype uint16, category uint16, eventId uint32, usrSId uintptr, numStrings uint16, dataSize uint32, strings **uint16, rawData *byte) (err error) {
1231
	r1, _, e1 := syscall.SyscallN(procReportEventW.Addr(), uintptr(log), uintptr(etype), uintptr(category), uintptr(eventId), uintptr(usrSId), uintptr(numStrings), uintptr(dataSize), uintptr(unsafe.Pointer(strings)), uintptr(unsafe.Pointer(rawData)))
1232
	if r1 == 0 {
1233
		err = errnoErr(e1)
1234
	}
1235
	return
1236
}
1237

1238
func RevertToSelf() (err error) {
1239
	r1, _, e1 := syscall.SyscallN(procRevertToSelf.Addr())
1240
	if r1 == 0 {
1241
		err = errnoErr(e1)
1242
	}
1243
	return
1244
}
1245

1246
func setEntriesInAcl(countExplicitEntries uint32, explicitEntries *EXPLICIT_ACCESS, oldACL *ACL, newACL **ACL) (ret error) {
1247
	r0, _, _ := syscall.SyscallN(procSetEntriesInAclW.Addr(), uintptr(countExplicitEntries), uintptr(unsafe.Pointer(explicitEntries)), uintptr(unsafe.Pointer(oldACL)), uintptr(unsafe.Pointer(newACL)))
1248
	if r0 != 0 {
1249
		ret = syscall.Errno(r0)
1250
	}
1251
	return
1252
}
1253

1254
func SetKernelObjectSecurity(handle Handle, securityInformation SECURITY_INFORMATION, securityDescriptor *SECURITY_DESCRIPTOR) (err error) {
1255
	r1, _, e1 := syscall.SyscallN(procSetKernelObjectSecurity.Addr(), uintptr(handle), uintptr(securityInformation), uintptr(unsafe.Pointer(securityDescriptor)))
1256
	if r1 == 0 {
1257
		err = errnoErr(e1)
1258
	}
1259
	return
1260
}
1261

1262
func SetNamedSecurityInfo(objectName string, objectType SE_OBJECT_TYPE, securityInformation SECURITY_INFORMATION, owner *SID, group *SID, dacl *ACL, sacl *ACL) (ret error) {
1263
	var _p0 *uint16
1264
	_p0, ret = syscall.UTF16PtrFromString(objectName)
1265
	if ret != nil {
1266
		return
1267
	}
1268
	return _SetNamedSecurityInfo(_p0, objectType, securityInformation, owner, group, dacl, sacl)
1269
}
1270

1271
func _SetNamedSecurityInfo(objectName *uint16, objectType SE_OBJECT_TYPE, securityInformation SECURITY_INFORMATION, owner *SID, group *SID, dacl *ACL, sacl *ACL) (ret error) {
1272
	r0, _, _ := syscall.SyscallN(procSetNamedSecurityInfoW.Addr(), uintptr(unsafe.Pointer(objectName)), uintptr(objectType), uintptr(securityInformation), uintptr(unsafe.Pointer(owner)), uintptr(unsafe.Pointer(group)), uintptr(unsafe.Pointer(dacl)), uintptr(unsafe.Pointer(sacl)))
1273
	if r0 != 0 {
1274
		ret = syscall.Errno(r0)
1275
	}
1276
	return
1277
}
1278

1279
func setSecurityDescriptorControl(sd *SECURITY_DESCRIPTOR, controlBitsOfInterest SECURITY_DESCRIPTOR_CONTROL, controlBitsToSet SECURITY_DESCRIPTOR_CONTROL) (err error) {
1280
	r1, _, e1 := syscall.SyscallN(procSetSecurityDescriptorControl.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(controlBitsOfInterest), uintptr(controlBitsToSet))
1281
	if r1 == 0 {
1282
		err = errnoErr(e1)
1283
	}
1284
	return
1285
}
1286

1287
func setSecurityDescriptorDacl(sd *SECURITY_DESCRIPTOR, daclPresent bool, dacl *ACL, daclDefaulted bool) (err error) {
1288
	var _p0 uint32
1289
	if daclPresent {
1290
		_p0 = 1
1291
	}
1292
	var _p1 uint32
1293
	if daclDefaulted {
1294
		_p1 = 1
1295
	}
1296
	r1, _, e1 := syscall.SyscallN(procSetSecurityDescriptorDacl.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(_p0), uintptr(unsafe.Pointer(dacl)), uintptr(_p1))
1297
	if r1 == 0 {
1298
		err = errnoErr(e1)
1299
	}
1300
	return
1301
}
1302

1303
func setSecurityDescriptorGroup(sd *SECURITY_DESCRIPTOR, group *SID, groupDefaulted bool) (err error) {
1304
	var _p0 uint32
1305
	if groupDefaulted {
1306
		_p0 = 1
1307
	}
1308
	r1, _, e1 := syscall.SyscallN(procSetSecurityDescriptorGroup.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(unsafe.Pointer(group)), uintptr(_p0))
1309
	if r1 == 0 {
1310
		err = errnoErr(e1)
1311
	}
1312
	return
1313
}
1314

1315
func setSecurityDescriptorOwner(sd *SECURITY_DESCRIPTOR, owner *SID, ownerDefaulted bool) (err error) {
1316
	var _p0 uint32
1317
	if ownerDefaulted {
1318
		_p0 = 1
1319
	}
1320
	r1, _, e1 := syscall.SyscallN(procSetSecurityDescriptorOwner.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(unsafe.Pointer(owner)), uintptr(_p0))
1321
	if r1 == 0 {
1322
		err = errnoErr(e1)
1323
	}
1324
	return
1325
}
1326

1327
func setSecurityDescriptorRMControl(sd *SECURITY_DESCRIPTOR, rmControl *uint8) {
1328
	syscall.SyscallN(procSetSecurityDescriptorRMControl.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(unsafe.Pointer(rmControl)))
1329
	return
1330
}
1331

1332
func setSecurityDescriptorSacl(sd *SECURITY_DESCRIPTOR, saclPresent bool, sacl *ACL, saclDefaulted bool) (err error) {
1333
	var _p0 uint32
1334
	if saclPresent {
1335
		_p0 = 1
1336
	}
1337
	var _p1 uint32
1338
	if saclDefaulted {
1339
		_p1 = 1
1340
	}
1341
	r1, _, e1 := syscall.SyscallN(procSetSecurityDescriptorSacl.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(_p0), uintptr(unsafe.Pointer(sacl)), uintptr(_p1))
1342
	if r1 == 0 {
1343
		err = errnoErr(e1)
1344
	}
1345
	return
1346
}
1347

1348
func SetSecurityInfo(handle Handle, objectType SE_OBJECT_TYPE, securityInformation SECURITY_INFORMATION, owner *SID, group *SID, dacl *ACL, sacl *ACL) (ret error) {
1349
	r0, _, _ := syscall.SyscallN(procSetSecurityInfo.Addr(), uintptr(handle), uintptr(objectType), uintptr(securityInformation), uintptr(unsafe.Pointer(owner)), uintptr(unsafe.Pointer(group)), uintptr(unsafe.Pointer(dacl)), uintptr(unsafe.Pointer(sacl)))
1350
	if r0 != 0 {
1351
		ret = syscall.Errno(r0)
1352
	}
1353
	return
1354
}
1355

1356
func SetServiceStatus(service Handle, serviceStatus *SERVICE_STATUS) (err error) {
1357
	r1, _, e1 := syscall.SyscallN(procSetServiceStatus.Addr(), uintptr(service), uintptr(unsafe.Pointer(serviceStatus)))
1358
	if r1 == 0 {
1359
		err = errnoErr(e1)
1360
	}
1361
	return
1362
}
1363

1364
func SetThreadToken(thread *Handle, token Token) (err error) {
1365
	r1, _, e1 := syscall.SyscallN(procSetThreadToken.Addr(), uintptr(unsafe.Pointer(thread)), uintptr(token))
1366
	if r1 == 0 {
1367
		err = errnoErr(e1)
1368
	}
1369
	return
1370
}
1371

1372
func SetTokenInformation(token Token, infoClass uint32, info *byte, infoLen uint32) (err error) {
1373
	r1, _, e1 := syscall.SyscallN(procSetTokenInformation.Addr(), uintptr(token), uintptr(infoClass), uintptr(unsafe.Pointer(info)), uintptr(infoLen))
1374
	if r1 == 0 {
1375
		err = errnoErr(e1)
1376
	}
1377
	return
1378
}
1379

1380
func StartServiceCtrlDispatcher(serviceTable *SERVICE_TABLE_ENTRY) (err error) {
1381
	r1, _, e1 := syscall.SyscallN(procStartServiceCtrlDispatcherW.Addr(), uintptr(unsafe.Pointer(serviceTable)))
1382
	if r1 == 0 {
1383
		err = errnoErr(e1)
1384
	}
1385
	return
1386
}
1387

1388
func StartService(service Handle, numArgs uint32, argVectors **uint16) (err error) {
1389
	r1, _, e1 := syscall.SyscallN(procStartServiceW.Addr(), uintptr(service), uintptr(numArgs), uintptr(unsafe.Pointer(argVectors)))
1390
	if r1 == 0 {
1391
		err = errnoErr(e1)
1392
	}
1393
	return
1394
}
1395

1396
func CertAddCertificateContextToStore(store Handle, certContext *CertContext, addDisposition uint32, storeContext **CertContext) (err error) {
1397
	r1, _, e1 := syscall.SyscallN(procCertAddCertificateContextToStore.Addr(), uintptr(store), uintptr(unsafe.Pointer(certContext)), uintptr(addDisposition), uintptr(unsafe.Pointer(storeContext)))
1398
	if r1 == 0 {
1399
		err = errnoErr(e1)
1400
	}
1401
	return
1402
}
1403

1404
func CertCloseStore(store Handle, flags uint32) (err error) {
1405
	r1, _, e1 := syscall.SyscallN(procCertCloseStore.Addr(), uintptr(store), uintptr(flags))
1406
	if r1 == 0 {
1407
		err = errnoErr(e1)
1408
	}
1409
	return
1410
}
1411

1412
func CertCreateCertificateContext(certEncodingType uint32, certEncoded *byte, encodedLen uint32) (context *CertContext, err error) {
1413
	r0, _, e1 := syscall.SyscallN(procCertCreateCertificateContext.Addr(), uintptr(certEncodingType), uintptr(unsafe.Pointer(certEncoded)), uintptr(encodedLen))
1414
	context = (*CertContext)(unsafe.Pointer(r0))
1415
	if context == nil {
1416
		err = errnoErr(e1)
1417
	}
1418
	return
1419
}
1420

1421
func CertDeleteCertificateFromStore(certContext *CertContext) (err error) {
1422
	r1, _, e1 := syscall.SyscallN(procCertDeleteCertificateFromStore.Addr(), uintptr(unsafe.Pointer(certContext)))
1423
	if r1 == 0 {
1424
		err = errnoErr(e1)
1425
	}
1426
	return
1427
}
1428

1429
func CertDuplicateCertificateContext(certContext *CertContext) (dupContext *CertContext) {
1430
	r0, _, _ := syscall.SyscallN(procCertDuplicateCertificateContext.Addr(), uintptr(unsafe.Pointer(certContext)))
1431
	dupContext = (*CertContext)(unsafe.Pointer(r0))
1432
	return
1433
}
1434

1435
func CertEnumCertificatesInStore(store Handle, prevContext *CertContext) (context *CertContext, err error) {
1436
	r0, _, e1 := syscall.SyscallN(procCertEnumCertificatesInStore.Addr(), uintptr(store), uintptr(unsafe.Pointer(prevContext)))
1437
	context = (*CertContext)(unsafe.Pointer(r0))
1438
	if context == nil {
1439
		err = errnoErr(e1)
1440
	}
1441
	return
1442
}
1443

1444
func CertFindCertificateInStore(store Handle, certEncodingType uint32, findFlags uint32, findType uint32, findPara unsafe.Pointer, prevCertContext *CertContext) (cert *CertContext, err error) {
1445
	r0, _, e1 := syscall.SyscallN(procCertFindCertificateInStore.Addr(), uintptr(store), uintptr(certEncodingType), uintptr(findFlags), uintptr(findType), uintptr(findPara), uintptr(unsafe.Pointer(prevCertContext)))
1446
	cert = (*CertContext)(unsafe.Pointer(r0))
1447
	if cert == nil {
1448
		err = errnoErr(e1)
1449
	}
1450
	return
1451
}
1452

1453
func CertFindChainInStore(store Handle, certEncodingType uint32, findFlags uint32, findType uint32, findPara unsafe.Pointer, prevChainContext *CertChainContext) (certchain *CertChainContext, err error) {
1454
	r0, _, e1 := syscall.SyscallN(procCertFindChainInStore.Addr(), uintptr(store), uintptr(certEncodingType), uintptr(findFlags), uintptr(findType), uintptr(findPara), uintptr(unsafe.Pointer(prevChainContext)))
1455
	certchain = (*CertChainContext)(unsafe.Pointer(r0))
1456
	if certchain == nil {
1457
		err = errnoErr(e1)
1458
	}
1459
	return
1460
}
1461

1462
func CertFindExtension(objId *byte, countExtensions uint32, extensions *CertExtension) (ret *CertExtension) {
1463
	r0, _, _ := syscall.SyscallN(procCertFindExtension.Addr(), uintptr(unsafe.Pointer(objId)), uintptr(countExtensions), uintptr(unsafe.Pointer(extensions)))
1464
	ret = (*CertExtension)(unsafe.Pointer(r0))
1465
	return
1466
}
1467

1468
func CertFreeCertificateChain(ctx *CertChainContext) {
1469
	syscall.SyscallN(procCertFreeCertificateChain.Addr(), uintptr(unsafe.Pointer(ctx)))
1470
	return
1471
}
1472

1473
func CertFreeCertificateContext(ctx *CertContext) (err error) {
1474
	r1, _, e1 := syscall.SyscallN(procCertFreeCertificateContext.Addr(), uintptr(unsafe.Pointer(ctx)))
1475
	if r1 == 0 {
1476
		err = errnoErr(e1)
1477
	}
1478
	return
1479
}
1480

1481
func CertGetCertificateChain(engine Handle, leaf *CertContext, time *Filetime, additionalStore Handle, para *CertChainPara, flags uint32, reserved uintptr, chainCtx **CertChainContext) (err error) {
1482
	r1, _, e1 := syscall.SyscallN(procCertGetCertificateChain.Addr(), uintptr(engine), uintptr(unsafe.Pointer(leaf)), uintptr(unsafe.Pointer(time)), uintptr(additionalStore), uintptr(unsafe.Pointer(para)), uintptr(flags), uintptr(reserved), uintptr(unsafe.Pointer(chainCtx)))
1483
	if r1 == 0 {
1484
		err = errnoErr(e1)
1485
	}
1486
	return
1487
}
1488

1489
func CertGetNameString(certContext *CertContext, nameType uint32, flags uint32, typePara unsafe.Pointer, name *uint16, size uint32) (chars uint32) {
1490
	r0, _, _ := syscall.SyscallN(procCertGetNameStringW.Addr(), uintptr(unsafe.Pointer(certContext)), uintptr(nameType), uintptr(flags), uintptr(typePara), uintptr(unsafe.Pointer(name)), uintptr(size))
1491
	chars = uint32(r0)
1492
	return
1493
}
1494

1495
func CertOpenStore(storeProvider uintptr, msgAndCertEncodingType uint32, cryptProv uintptr, flags uint32, para uintptr) (handle Handle, err error) {
1496
	r0, _, e1 := syscall.SyscallN(procCertOpenStore.Addr(), uintptr(storeProvider), uintptr(msgAndCertEncodingType), uintptr(cryptProv), uintptr(flags), uintptr(para))
1497
	handle = Handle(r0)
1498
	if handle == 0 {
1499
		err = errnoErr(e1)
1500
	}
1501
	return
1502
}
1503

1504
func CertOpenSystemStore(hprov Handle, name *uint16) (store Handle, err error) {
1505
	r0, _, e1 := syscall.SyscallN(procCertOpenSystemStoreW.Addr(), uintptr(hprov), uintptr(unsafe.Pointer(name)))
1506
	store = Handle(r0)
1507
	if store == 0 {
1508
		err = errnoErr(e1)
1509
	}
1510
	return
1511
}
1512

1513
func CertVerifyCertificateChainPolicy(policyOID uintptr, chain *CertChainContext, para *CertChainPolicyPara, status *CertChainPolicyStatus) (err error) {
1514
	r1, _, e1 := syscall.SyscallN(procCertVerifyCertificateChainPolicy.Addr(), uintptr(policyOID), uintptr(unsafe.Pointer(chain)), uintptr(unsafe.Pointer(para)), uintptr(unsafe.Pointer(status)))
1515
	if r1 == 0 {
1516
		err = errnoErr(e1)
1517
	}
1518
	return
1519
}
1520

1521
func CryptAcquireCertificatePrivateKey(cert *CertContext, flags uint32, parameters unsafe.Pointer, cryptProvOrNCryptKey *Handle, keySpec *uint32, callerFreeProvOrNCryptKey *bool) (err error) {
1522
	var _p0 uint32
1523
	if *callerFreeProvOrNCryptKey {
1524
		_p0 = 1
1525
	}
1526
	r1, _, e1 := syscall.SyscallN(procCryptAcquireCertificatePrivateKey.Addr(), uintptr(unsafe.Pointer(cert)), uintptr(flags), uintptr(parameters), uintptr(unsafe.Pointer(cryptProvOrNCryptKey)), uintptr(unsafe.Pointer(keySpec)), uintptr(unsafe.Pointer(&_p0)))
1527
	*callerFreeProvOrNCryptKey = _p0 != 0
1528
	if r1 == 0 {
1529
		err = errnoErr(e1)
1530
	}
1531
	return
1532
}
1533

1534
func CryptDecodeObject(encodingType uint32, structType *byte, encodedBytes *byte, lenEncodedBytes uint32, flags uint32, decoded unsafe.Pointer, decodedLen *uint32) (err error) {
1535
	r1, _, e1 := syscall.SyscallN(procCryptDecodeObject.Addr(), uintptr(encodingType), uintptr(unsafe.Pointer(structType)), uintptr(unsafe.Pointer(encodedBytes)), uintptr(lenEncodedBytes), uintptr(flags), uintptr(decoded), uintptr(unsafe.Pointer(decodedLen)))
1536
	if r1 == 0 {
1537
		err = errnoErr(e1)
1538
	}
1539
	return
1540
}
1541

1542
func CryptProtectData(dataIn *DataBlob, name *uint16, optionalEntropy *DataBlob, reserved uintptr, promptStruct *CryptProtectPromptStruct, flags uint32, dataOut *DataBlob) (err error) {
1543
	r1, _, e1 := syscall.SyscallN(procCryptProtectData.Addr(), uintptr(unsafe.Pointer(dataIn)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(optionalEntropy)), uintptr(reserved), uintptr(unsafe.Pointer(promptStruct)), uintptr(flags), uintptr(unsafe.Pointer(dataOut)))
1544
	if r1 == 0 {
1545
		err = errnoErr(e1)
1546
	}
1547
	return
1548
}
1549

1550
func CryptQueryObject(objectType uint32, object unsafe.Pointer, expectedContentTypeFlags uint32, expectedFormatTypeFlags uint32, flags uint32, msgAndCertEncodingType *uint32, contentType *uint32, formatType *uint32, certStore *Handle, msg *Handle, context *unsafe.Pointer) (err error) {
1551
	r1, _, e1 := syscall.SyscallN(procCryptQueryObject.Addr(), uintptr(objectType), uintptr(object), uintptr(expectedContentTypeFlags), uintptr(expectedFormatTypeFlags), uintptr(flags), uintptr(unsafe.Pointer(msgAndCertEncodingType)), uintptr(unsafe.Pointer(contentType)), uintptr(unsafe.Pointer(formatType)), uintptr(unsafe.Pointer(certStore)), uintptr(unsafe.Pointer(msg)), uintptr(unsafe.Pointer(context)))
1552
	if r1 == 0 {
1553
		err = errnoErr(e1)
1554
	}
1555
	return
1556
}
1557

1558
func CryptUnprotectData(dataIn *DataBlob, name **uint16, optionalEntropy *DataBlob, reserved uintptr, promptStruct *CryptProtectPromptStruct, flags uint32, dataOut *DataBlob) (err error) {
1559
	r1, _, e1 := syscall.SyscallN(procCryptUnprotectData.Addr(), uintptr(unsafe.Pointer(dataIn)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(optionalEntropy)), uintptr(reserved), uintptr(unsafe.Pointer(promptStruct)), uintptr(flags), uintptr(unsafe.Pointer(dataOut)))
1560
	if r1 == 0 {
1561
		err = errnoErr(e1)
1562
	}
1563
	return
1564
}
1565

1566
func PFXImportCertStore(pfx *CryptDataBlob, password *uint16, flags uint32) (store Handle, err error) {
1567
	r0, _, e1 := syscall.SyscallN(procPFXImportCertStore.Addr(), uintptr(unsafe.Pointer(pfx)), uintptr(unsafe.Pointer(password)), uintptr(flags))
1568
	store = Handle(r0)
1569
	if store == 0 {
1570
		err = errnoErr(e1)
1571
	}
1572
	return
1573
}
1574

1575
func DnsNameCompare(name1 *uint16, name2 *uint16) (same bool) {
1576
	r0, _, _ := syscall.SyscallN(procDnsNameCompare_W.Addr(), uintptr(unsafe.Pointer(name1)), uintptr(unsafe.Pointer(name2)))
1577
	same = r0 != 0
1578
	return
1579
}
1580

1581
func DnsQuery(name string, qtype uint16, options uint32, extra *byte, qrs **DNSRecord, pr *byte) (status error) {
1582
	var _p0 *uint16
1583
	_p0, status = syscall.UTF16PtrFromString(name)
1584
	if status != nil {
1585
		return
1586
	}
1587
	return _DnsQuery(_p0, qtype, options, extra, qrs, pr)
1588
}
1589

1590
func _DnsQuery(name *uint16, qtype uint16, options uint32, extra *byte, qrs **DNSRecord, pr *byte) (status error) {
1591
	r0, _, _ := syscall.SyscallN(procDnsQuery_W.Addr(), uintptr(unsafe.Pointer(name)), uintptr(qtype), uintptr(options), uintptr(unsafe.Pointer(extra)), uintptr(unsafe.Pointer(qrs)), uintptr(unsafe.Pointer(pr)))
1592
	if r0 != 0 {
1593
		status = syscall.Errno(r0)
1594
	}
1595
	return
1596
}
1597

1598
func DnsRecordListFree(rl *DNSRecord, freetype uint32) {
1599
	syscall.SyscallN(procDnsRecordListFree.Addr(), uintptr(unsafe.Pointer(rl)), uintptr(freetype))
1600
	return
1601
}
1602

1603
func DwmGetWindowAttribute(hwnd HWND, attribute uint32, value unsafe.Pointer, size uint32) (ret error) {
1604
	r0, _, _ := syscall.SyscallN(procDwmGetWindowAttribute.Addr(), uintptr(hwnd), uintptr(attribute), uintptr(value), uintptr(size))
1605
	if r0 != 0 {
1606
		ret = syscall.Errno(r0)
1607
	}
1608
	return
1609
}
1610

1611
func DwmSetWindowAttribute(hwnd HWND, attribute uint32, value unsafe.Pointer, size uint32) (ret error) {
1612
	r0, _, _ := syscall.SyscallN(procDwmSetWindowAttribute.Addr(), uintptr(hwnd), uintptr(attribute), uintptr(value), uintptr(size))
1613
	if r0 != 0 {
1614
		ret = syscall.Errno(r0)
1615
	}
1616
	return
1617
}
1618

1619
func CancelMibChangeNotify2(notificationHandle Handle) (errcode error) {
1620
	r0, _, _ := syscall.SyscallN(procCancelMibChangeNotify2.Addr(), uintptr(notificationHandle))
1621
	if r0 != 0 {
1622
		errcode = syscall.Errno(r0)
1623
	}
1624
	return
1625
}
1626

1627
func GetAdaptersAddresses(family uint32, flags uint32, reserved uintptr, adapterAddresses *IpAdapterAddresses, sizePointer *uint32) (errcode error) {
1628
	r0, _, _ := syscall.SyscallN(procGetAdaptersAddresses.Addr(), uintptr(family), uintptr(flags), uintptr(reserved), uintptr(unsafe.Pointer(adapterAddresses)), uintptr(unsafe.Pointer(sizePointer)))
1629
	if r0 != 0 {
1630
		errcode = syscall.Errno(r0)
1631
	}
1632
	return
1633
}
1634

1635
func GetAdaptersInfo(ai *IpAdapterInfo, ol *uint32) (errcode error) {
1636
	r0, _, _ := syscall.SyscallN(procGetAdaptersInfo.Addr(), uintptr(unsafe.Pointer(ai)), uintptr(unsafe.Pointer(ol)))
1637
	if r0 != 0 {
1638
		errcode = syscall.Errno(r0)
1639
	}
1640
	return
1641
}
1642

1643
func getBestInterfaceEx(sockaddr unsafe.Pointer, pdwBestIfIndex *uint32) (errcode error) {
1644
	r0, _, _ := syscall.SyscallN(procGetBestInterfaceEx.Addr(), uintptr(sockaddr), uintptr(unsafe.Pointer(pdwBestIfIndex)))
1645
	if r0 != 0 {
1646
		errcode = syscall.Errno(r0)
1647
	}
1648
	return
1649
}
1650

1651
func GetIfEntry(pIfRow *MibIfRow) (errcode error) {
1652
	r0, _, _ := syscall.SyscallN(procGetIfEntry.Addr(), uintptr(unsafe.Pointer(pIfRow)))
1653
	if r0 != 0 {
1654
		errcode = syscall.Errno(r0)
1655
	}
1656
	return
1657
}
1658

1659
func GetIfEntry2Ex(level uint32, row *MibIfRow2) (errcode error) {
1660
	r0, _, _ := syscall.SyscallN(procGetIfEntry2Ex.Addr(), uintptr(level), uintptr(unsafe.Pointer(row)))
1661
	if r0 != 0 {
1662
		errcode = syscall.Errno(r0)
1663
	}
1664
	return
1665
}
1666

1667
func GetUnicastIpAddressEntry(row *MibUnicastIpAddressRow) (errcode error) {
1668
	r0, _, _ := syscall.SyscallN(procGetUnicastIpAddressEntry.Addr(), uintptr(unsafe.Pointer(row)))
1669
	if r0 != 0 {
1670
		errcode = syscall.Errno(r0)
1671
	}
1672
	return
1673
}
1674

1675
func NotifyIpInterfaceChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) {
1676
	var _p0 uint32
1677
	if initialNotification {
1678
		_p0 = 1
1679
	}
1680
	r0, _, _ := syscall.SyscallN(procNotifyIpInterfaceChange.Addr(), uintptr(family), uintptr(callback), uintptr(callerContext), uintptr(_p0), uintptr(unsafe.Pointer(notificationHandle)))
1681
	if r0 != 0 {
1682
		errcode = syscall.Errno(r0)
1683
	}
1684
	return
1685
}
1686

1687
func NotifyUnicastIpAddressChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) {
1688
	var _p0 uint32
1689
	if initialNotification {
1690
		_p0 = 1
1691
	}
1692
	r0, _, _ := syscall.SyscallN(procNotifyUnicastIpAddressChange.Addr(), uintptr(family), uintptr(callback), uintptr(callerContext), uintptr(_p0), uintptr(unsafe.Pointer(notificationHandle)))
1693
	if r0 != 0 {
1694
		errcode = syscall.Errno(r0)
1695
	}
1696
	return
1697
}
1698

1699
func AddDllDirectory(path *uint16) (cookie uintptr, err error) {
1700
	r0, _, e1 := syscall.SyscallN(procAddDllDirectory.Addr(), uintptr(unsafe.Pointer(path)))
1701
	cookie = uintptr(r0)
1702
	if cookie == 0 {
1703
		err = errnoErr(e1)
1704
	}
1705
	return
1706
}
1707

1708
func AssignProcessToJobObject(job Handle, process Handle) (err error) {
1709
	r1, _, e1 := syscall.SyscallN(procAssignProcessToJobObject.Addr(), uintptr(job), uintptr(process))
1710
	if r1 == 0 {
1711
		err = errnoErr(e1)
1712
	}
1713
	return
1714
}
1715

1716
func CancelIo(s Handle) (err error) {
1717
	r1, _, e1 := syscall.SyscallN(procCancelIo.Addr(), uintptr(s))
1718
	if r1 == 0 {
1719
		err = errnoErr(e1)
1720
	}
1721
	return
1722
}
1723

1724
func CancelIoEx(s Handle, o *Overlapped) (err error) {
1725
	r1, _, e1 := syscall.SyscallN(procCancelIoEx.Addr(), uintptr(s), uintptr(unsafe.Pointer(o)))
1726
	if r1 == 0 {
1727
		err = errnoErr(e1)
1728
	}
1729
	return
1730
}
1731

1732
func ClearCommBreak(handle Handle) (err error) {
1733
	r1, _, e1 := syscall.SyscallN(procClearCommBreak.Addr(), uintptr(handle))
1734
	if r1 == 0 {
1735
		err = errnoErr(e1)
1736
	}
1737
	return
1738
}
1739

1740
func ClearCommError(handle Handle, lpErrors *uint32, lpStat *ComStat) (err error) {
1741
	r1, _, e1 := syscall.SyscallN(procClearCommError.Addr(), uintptr(handle), uintptr(unsafe.Pointer(lpErrors)), uintptr(unsafe.Pointer(lpStat)))
1742
	if r1 == 0 {
1743
		err = errnoErr(e1)
1744
	}
1745
	return
1746
}
1747

1748
func CloseHandle(handle Handle) (err error) {
1749
	r1, _, e1 := syscall.SyscallN(procCloseHandle.Addr(), uintptr(handle))
1750
	if r1 == 0 {
1751
		err = errnoErr(e1)
1752
	}
1753
	return
1754
}
1755

1756
func ClosePseudoConsole(console Handle) {
1757
	syscall.SyscallN(procClosePseudoConsole.Addr(), uintptr(console))
1758
	return
1759
}
1760

1761
func ConnectNamedPipe(pipe Handle, overlapped *Overlapped) (err error) {
1762
	r1, _, e1 := syscall.SyscallN(procConnectNamedPipe.Addr(), uintptr(pipe), uintptr(unsafe.Pointer(overlapped)))
1763
	if r1 == 0 {
1764
		err = errnoErr(e1)
1765
	}
1766
	return
1767
}
1768

1769
func CreateDirectory(path *uint16, sa *SecurityAttributes) (err error) {
1770
	r1, _, e1 := syscall.SyscallN(procCreateDirectoryW.Addr(), uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(sa)))
1771
	if r1 == 0 {
1772
		err = errnoErr(e1)
1773
	}
1774
	return
1775
}
1776

1777
func CreateEventEx(eventAttrs *SecurityAttributes, name *uint16, flags uint32, desiredAccess uint32) (handle Handle, err error) {
1778
	r0, _, e1 := syscall.SyscallN(procCreateEventExW.Addr(), uintptr(unsafe.Pointer(eventAttrs)), uintptr(unsafe.Pointer(name)), uintptr(flags), uintptr(desiredAccess))
1779
	handle = Handle(r0)
1780
	if handle == 0 || e1 == ERROR_ALREADY_EXISTS {
1781
		err = errnoErr(e1)
1782
	}
1783
	return
1784
}
1785

1786
func CreateEvent(eventAttrs *SecurityAttributes, manualReset uint32, initialState uint32, name *uint16) (handle Handle, err error) {
1787
	r0, _, e1 := syscall.SyscallN(procCreateEventW.Addr(), uintptr(unsafe.Pointer(eventAttrs)), uintptr(manualReset), uintptr(initialState), uintptr(unsafe.Pointer(name)))
1788
	handle = Handle(r0)
1789
	if handle == 0 || e1 == ERROR_ALREADY_EXISTS {
1790
		err = errnoErr(e1)
1791
	}
1792
	return
1793
}
1794

1795
func CreateFileMapping(fhandle Handle, sa *SecurityAttributes, prot uint32, maxSizeHigh uint32, maxSizeLow uint32, name *uint16) (handle Handle, err error) {
1796
	r0, _, e1 := syscall.SyscallN(procCreateFileMappingW.Addr(), uintptr(fhandle), uintptr(unsafe.Pointer(sa)), uintptr(prot), uintptr(maxSizeHigh), uintptr(maxSizeLow), uintptr(unsafe.Pointer(name)))
1797
	handle = Handle(r0)
1798
	if handle == 0 || e1 == ERROR_ALREADY_EXISTS {
1799
		err = errnoErr(e1)
1800
	}
1801
	return
1802
}
1803

1804
func CreateFile(name *uint16, access uint32, mode uint32, sa *SecurityAttributes, createmode uint32, attrs uint32, templatefile Handle) (handle Handle, err error) {
1805
	r0, _, e1 := syscall.SyscallN(procCreateFileW.Addr(), uintptr(unsafe.Pointer(name)), uintptr(access), uintptr(mode), uintptr(unsafe.Pointer(sa)), uintptr(createmode), uintptr(attrs), uintptr(templatefile))
1806
	handle = Handle(r0)
1807
	if handle == InvalidHandle {
1808
		err = errnoErr(e1)
1809
	}
1810
	return
1811
}
1812

1813
func CreateHardLink(filename *uint16, existingfilename *uint16, reserved uintptr) (err error) {
1814
	r1, _, e1 := syscall.SyscallN(procCreateHardLinkW.Addr(), uintptr(unsafe.Pointer(filename)), uintptr(unsafe.Pointer(existingfilename)), uintptr(reserved))
1815
	if r1&0xff == 0 {
1816
		err = errnoErr(e1)
1817
	}
1818
	return
1819
}
1820

1821
func CreateIoCompletionPort(filehandle Handle, cphandle Handle, key uintptr, threadcnt uint32) (handle Handle, err error) {
1822
	r0, _, e1 := syscall.SyscallN(procCreateIoCompletionPort.Addr(), uintptr(filehandle), uintptr(cphandle), uintptr(key), uintptr(threadcnt))
1823
	handle = Handle(r0)
1824
	if handle == 0 {
1825
		err = errnoErr(e1)
1826
	}
1827
	return
1828
}
1829

1830
func CreateJobObject(jobAttr *SecurityAttributes, name *uint16) (handle Handle, err error) {
1831
	r0, _, e1 := syscall.SyscallN(procCreateJobObjectW.Addr(), uintptr(unsafe.Pointer(jobAttr)), uintptr(unsafe.Pointer(name)))
1832
	handle = Handle(r0)
1833
	if handle == 0 {
1834
		err = errnoErr(e1)
1835
	}
1836
	return
1837
}
1838

1839
func CreateMutexEx(mutexAttrs *SecurityAttributes, name *uint16, flags uint32, desiredAccess uint32) (handle Handle, err error) {
1840
	r0, _, e1 := syscall.SyscallN(procCreateMutexExW.Addr(), uintptr(unsafe.Pointer(mutexAttrs)), uintptr(unsafe.Pointer(name)), uintptr(flags), uintptr(desiredAccess))
1841
	handle = Handle(r0)
1842
	if handle == 0 || e1 == ERROR_ALREADY_EXISTS {
1843
		err = errnoErr(e1)
1844
	}
1845
	return
1846
}
1847

1848
func CreateMutex(mutexAttrs *SecurityAttributes, initialOwner bool, name *uint16) (handle Handle, err error) {
1849
	var _p0 uint32
1850
	if initialOwner {
1851
		_p0 = 1
1852
	}
1853
	r0, _, e1 := syscall.SyscallN(procCreateMutexW.Addr(), uintptr(unsafe.Pointer(mutexAttrs)), uintptr(_p0), uintptr(unsafe.Pointer(name)))
1854
	handle = Handle(r0)
1855
	if handle == 0 || e1 == ERROR_ALREADY_EXISTS {
1856
		err = errnoErr(e1)
1857
	}
1858
	return
1859
}
1860

1861
func CreateNamedPipe(name *uint16, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *SecurityAttributes) (handle Handle, err error) {
1862
	r0, _, e1 := syscall.SyscallN(procCreateNamedPipeW.Addr(), uintptr(unsafe.Pointer(name)), uintptr(flags), uintptr(pipeMode), uintptr(maxInstances), uintptr(outSize), uintptr(inSize), uintptr(defaultTimeout), uintptr(unsafe.Pointer(sa)))
1863
	handle = Handle(r0)
1864
	if handle == InvalidHandle {
1865
		err = errnoErr(e1)
1866
	}
1867
	return
1868
}
1869

1870
func CreatePipe(readhandle *Handle, writehandle *Handle, sa *SecurityAttributes, size uint32) (err error) {
1871
	r1, _, e1 := syscall.SyscallN(procCreatePipe.Addr(), uintptr(unsafe.Pointer(readhandle)), uintptr(unsafe.Pointer(writehandle)), uintptr(unsafe.Pointer(sa)), uintptr(size))
1872
	if r1 == 0 {
1873
		err = errnoErr(e1)
1874
	}
1875
	return
1876
}
1877

1878
func CreateProcess(appName *uint16, commandLine *uint16, procSecurity *SecurityAttributes, threadSecurity *SecurityAttributes, inheritHandles bool, creationFlags uint32, env *uint16, currentDir *uint16, startupInfo *StartupInfo, outProcInfo *ProcessInformation) (err error) {
1879
	var _p0 uint32
1880
	if inheritHandles {
1881
		_p0 = 1
1882
	}
1883
	r1, _, e1 := syscall.SyscallN(procCreateProcessW.Addr(), uintptr(unsafe.Pointer(appName)), uintptr(unsafe.Pointer(commandLine)), uintptr(unsafe.Pointer(procSecurity)), uintptr(unsafe.Pointer(threadSecurity)), uintptr(_p0), uintptr(creationFlags), uintptr(unsafe.Pointer(env)), uintptr(unsafe.Pointer(currentDir)), uintptr(unsafe.Pointer(startupInfo)), uintptr(unsafe.Pointer(outProcInfo)))
1884
	if r1 == 0 {
1885
		err = errnoErr(e1)
1886
	}
1887
	return
1888
}
1889

1890
func createPseudoConsole(size uint32, in Handle, out Handle, flags uint32, pconsole *Handle) (hr error) {
1891
	r0, _, _ := syscall.SyscallN(procCreatePseudoConsole.Addr(), uintptr(size), uintptr(in), uintptr(out), uintptr(flags), uintptr(unsafe.Pointer(pconsole)))
1892
	if r0 != 0 {
1893
		hr = syscall.Errno(r0)
1894
	}
1895
	return
1896
}
1897

1898
func CreateSymbolicLink(symlinkfilename *uint16, targetfilename *uint16, flags uint32) (err error) {
1899
	r1, _, e1 := syscall.SyscallN(procCreateSymbolicLinkW.Addr(), uintptr(unsafe.Pointer(symlinkfilename)), uintptr(unsafe.Pointer(targetfilename)), uintptr(flags))
1900
	if r1&0xff == 0 {
1901
		err = errnoErr(e1)
1902
	}
1903
	return
1904
}
1905

1906
func CreateToolhelp32Snapshot(flags uint32, processId uint32) (handle Handle, err error) {
1907
	r0, _, e1 := syscall.SyscallN(procCreateToolhelp32Snapshot.Addr(), uintptr(flags), uintptr(processId))
1908
	handle = Handle(r0)
1909
	if handle == InvalidHandle {
1910
		err = errnoErr(e1)
1911
	}
1912
	return
1913
}
1914

1915
func DefineDosDevice(flags uint32, deviceName *uint16, targetPath *uint16) (err error) {
1916
	r1, _, e1 := syscall.SyscallN(procDefineDosDeviceW.Addr(), uintptr(flags), uintptr(unsafe.Pointer(deviceName)), uintptr(unsafe.Pointer(targetPath)))
1917
	if r1 == 0 {
1918
		err = errnoErr(e1)
1919
	}
1920
	return
1921
}
1922

1923
func DeleteFile(path *uint16) (err error) {
1924
	r1, _, e1 := syscall.SyscallN(procDeleteFileW.Addr(), uintptr(unsafe.Pointer(path)))
1925
	if r1 == 0 {
1926
		err = errnoErr(e1)
1927
	}
1928
	return
1929
}
1930

1931
func deleteProcThreadAttributeList(attrlist *ProcThreadAttributeList) {
1932
	syscall.SyscallN(procDeleteProcThreadAttributeList.Addr(), uintptr(unsafe.Pointer(attrlist)))
1933
	return
1934
}
1935

1936
func DeleteVolumeMountPoint(volumeMountPoint *uint16) (err error) {
1937
	r1, _, e1 := syscall.SyscallN(procDeleteVolumeMountPointW.Addr(), uintptr(unsafe.Pointer(volumeMountPoint)))
1938
	if r1 == 0 {
1939
		err = errnoErr(e1)
1940
	}
1941
	return
1942
}
1943

1944
func DeviceIoControl(handle Handle, ioControlCode uint32, inBuffer *byte, inBufferSize uint32, outBuffer *byte, outBufferSize uint32, bytesReturned *uint32, overlapped *Overlapped) (err error) {
1945
	r1, _, e1 := syscall.SyscallN(procDeviceIoControl.Addr(), uintptr(handle), uintptr(ioControlCode), uintptr(unsafe.Pointer(inBuffer)), uintptr(inBufferSize), uintptr(unsafe.Pointer(outBuffer)), uintptr(outBufferSize), uintptr(unsafe.Pointer(bytesReturned)), uintptr(unsafe.Pointer(overlapped)))
1946
	if r1 == 0 {
1947
		err = errnoErr(e1)
1948
	}
1949
	return
1950
}
1951

1952
func DisconnectNamedPipe(pipe Handle) (err error) {
1953
	r1, _, e1 := syscall.SyscallN(procDisconnectNamedPipe.Addr(), uintptr(pipe))
1954
	if r1 == 0 {
1955
		err = errnoErr(e1)
1956
	}
1957
	return
1958
}
1959

1960
func DuplicateHandle(hSourceProcessHandle Handle, hSourceHandle Handle, hTargetProcessHandle Handle, lpTargetHandle *Handle, dwDesiredAccess uint32, bInheritHandle bool, dwOptions uint32) (err error) {
1961
	var _p0 uint32
1962
	if bInheritHandle {
1963
		_p0 = 1
1964
	}
1965
	r1, _, e1 := syscall.SyscallN(procDuplicateHandle.Addr(), uintptr(hSourceProcessHandle), uintptr(hSourceHandle), uintptr(hTargetProcessHandle), uintptr(unsafe.Pointer(lpTargetHandle)), uintptr(dwDesiredAccess), uintptr(_p0), uintptr(dwOptions))
1966
	if r1 == 0 {
1967
		err = errnoErr(e1)
1968
	}
1969
	return
1970
}
1971

1972
func EscapeCommFunction(handle Handle, dwFunc uint32) (err error) {
1973
	r1, _, e1 := syscall.SyscallN(procEscapeCommFunction.Addr(), uintptr(handle), uintptr(dwFunc))
1974
	if r1 == 0 {
1975
		err = errnoErr(e1)
1976
	}
1977
	return
1978
}
1979

1980
func ExitProcess(exitcode uint32) {
1981
	syscall.SyscallN(procExitProcess.Addr(), uintptr(exitcode))
1982
	return
1983
}
1984

1985
func ExpandEnvironmentStrings(src *uint16, dst *uint16, size uint32) (n uint32, err error) {
1986
	r0, _, e1 := syscall.SyscallN(procExpandEnvironmentStringsW.Addr(), uintptr(unsafe.Pointer(src)), uintptr(unsafe.Pointer(dst)), uintptr(size))
1987
	n = uint32(r0)
1988
	if n == 0 {
1989
		err = errnoErr(e1)
1990
	}
1991
	return
1992
}
1993

1994
func FindClose(handle Handle) (err error) {
1995
	r1, _, e1 := syscall.SyscallN(procFindClose.Addr(), uintptr(handle))
1996
	if r1 == 0 {
1997
		err = errnoErr(e1)
1998
	}
1999
	return
2000
}
2001

2002
func FindCloseChangeNotification(handle Handle) (err error) {
2003
	r1, _, e1 := syscall.SyscallN(procFindCloseChangeNotification.Addr(), uintptr(handle))
2004
	if r1 == 0 {
2005
		err = errnoErr(e1)
2006
	}
2007
	return
2008
}
2009

2010
func FindFirstChangeNotification(path string, watchSubtree bool, notifyFilter uint32) (handle Handle, err error) {
2011
	var _p0 *uint16
2012
	_p0, err = syscall.UTF16PtrFromString(path)
2013
	if err != nil {
2014
		return
2015
	}
2016
	return _FindFirstChangeNotification(_p0, watchSubtree, notifyFilter)
2017
}
2018

2019
func _FindFirstChangeNotification(path *uint16, watchSubtree bool, notifyFilter uint32) (handle Handle, err error) {
2020
	var _p1 uint32
2021
	if watchSubtree {
2022
		_p1 = 1
2023
	}
2024
	r0, _, e1 := syscall.SyscallN(procFindFirstChangeNotificationW.Addr(), uintptr(unsafe.Pointer(path)), uintptr(_p1), uintptr(notifyFilter))
2025
	handle = Handle(r0)
2026
	if handle == InvalidHandle {
2027
		err = errnoErr(e1)
2028
	}
2029
	return
2030
}
2031

2032
func findFirstFile1(name *uint16, data *win32finddata1) (handle Handle, err error) {
2033
	r0, _, e1 := syscall.SyscallN(procFindFirstFileW.Addr(), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(data)))
2034
	handle = Handle(r0)
2035
	if handle == InvalidHandle {
2036
		err = errnoErr(e1)
2037
	}
2038
	return
2039
}
2040

2041
func FindFirstVolumeMountPoint(rootPathName *uint16, volumeMountPoint *uint16, bufferLength uint32) (handle Handle, err error) {
2042
	r0, _, e1 := syscall.SyscallN(procFindFirstVolumeMountPointW.Addr(), uintptr(unsafe.Pointer(rootPathName)), uintptr(unsafe.Pointer(volumeMountPoint)), uintptr(bufferLength))
2043
	handle = Handle(r0)
2044
	if handle == InvalidHandle {
2045
		err = errnoErr(e1)
2046
	}
2047
	return
2048
}
2049

2050
func FindFirstVolume(volumeName *uint16, bufferLength uint32) (handle Handle, err error) {
2051
	r0, _, e1 := syscall.SyscallN(procFindFirstVolumeW.Addr(), uintptr(unsafe.Pointer(volumeName)), uintptr(bufferLength))
2052
	handle = Handle(r0)
2053
	if handle == InvalidHandle {
2054
		err = errnoErr(e1)
2055
	}
2056
	return
2057
}
2058

2059
func FindNextChangeNotification(handle Handle) (err error) {
2060
	r1, _, e1 := syscall.SyscallN(procFindNextChangeNotification.Addr(), uintptr(handle))
2061
	if r1 == 0 {
2062
		err = errnoErr(e1)
2063
	}
2064
	return
2065
}
2066

2067
func findNextFile1(handle Handle, data *win32finddata1) (err error) {
2068
	r1, _, e1 := syscall.SyscallN(procFindNextFileW.Addr(), uintptr(handle), uintptr(unsafe.Pointer(data)))
2069
	if r1 == 0 {
2070
		err = errnoErr(e1)
2071
	}
2072
	return
2073
}
2074

2075
func FindNextVolumeMountPoint(findVolumeMountPoint Handle, volumeMountPoint *uint16, bufferLength uint32) (err error) {
2076
	r1, _, e1 := syscall.SyscallN(procFindNextVolumeMountPointW.Addr(), uintptr(findVolumeMountPoint), uintptr(unsafe.Pointer(volumeMountPoint)), uintptr(bufferLength))
2077
	if r1 == 0 {
2078
		err = errnoErr(e1)
2079
	}
2080
	return
2081
}
2082

2083
func FindNextVolume(findVolume Handle, volumeName *uint16, bufferLength uint32) (err error) {
2084
	r1, _, e1 := syscall.SyscallN(procFindNextVolumeW.Addr(), uintptr(findVolume), uintptr(unsafe.Pointer(volumeName)), uintptr(bufferLength))
2085
	if r1 == 0 {
2086
		err = errnoErr(e1)
2087
	}
2088
	return
2089
}
2090

2091
func findResource(module Handle, name uintptr, resType uintptr) (resInfo Handle, err error) {
2092
	r0, _, e1 := syscall.SyscallN(procFindResourceW.Addr(), uintptr(module), uintptr(name), uintptr(resType))
2093
	resInfo = Handle(r0)
2094
	if resInfo == 0 {
2095
		err = errnoErr(e1)
2096
	}
2097
	return
2098
}
2099

2100
func FindVolumeClose(findVolume Handle) (err error) {
2101
	r1, _, e1 := syscall.SyscallN(procFindVolumeClose.Addr(), uintptr(findVolume))
2102
	if r1 == 0 {
2103
		err = errnoErr(e1)
2104
	}
2105
	return
2106
}
2107

2108
func FindVolumeMountPointClose(findVolumeMountPoint Handle) (err error) {
2109
	r1, _, e1 := syscall.SyscallN(procFindVolumeMountPointClose.Addr(), uintptr(findVolumeMountPoint))
2110
	if r1 == 0 {
2111
		err = errnoErr(e1)
2112
	}
2113
	return
2114
}
2115

2116
func FlushConsoleInputBuffer(console Handle) (err error) {
2117
	r1, _, e1 := syscall.SyscallN(procFlushConsoleInputBuffer.Addr(), uintptr(console))
2118
	if r1 == 0 {
2119
		err = errnoErr(e1)
2120
	}
2121
	return
2122
}
2123

2124
func FlushFileBuffers(handle Handle) (err error) {
2125
	r1, _, e1 := syscall.SyscallN(procFlushFileBuffers.Addr(), uintptr(handle))
2126
	if r1 == 0 {
2127
		err = errnoErr(e1)
2128
	}
2129
	return
2130
}
2131

2132
func FlushViewOfFile(addr uintptr, length uintptr) (err error) {
2133
	r1, _, e1 := syscall.SyscallN(procFlushViewOfFile.Addr(), uintptr(addr), uintptr(length))
2134
	if r1 == 0 {
2135
		err = errnoErr(e1)
2136
	}
2137
	return
2138
}
2139

2140
func FormatMessage(flags uint32, msgsrc uintptr, msgid uint32, langid uint32, buf []uint16, args *byte) (n uint32, err error) {
2141
	var _p0 *uint16
2142
	if len(buf) > 0 {
2143
		_p0 = &buf[0]
2144
	}
2145
	r0, _, e1 := syscall.SyscallN(procFormatMessageW.Addr(), uintptr(flags), uintptr(msgsrc), uintptr(msgid), uintptr(langid), uintptr(unsafe.Pointer(_p0)), uintptr(len(buf)), uintptr(unsafe.Pointer(args)))
2146
	n = uint32(r0)
2147
	if n == 0 {
2148
		err = errnoErr(e1)
2149
	}
2150
	return
2151
}
2152

2153
func FreeEnvironmentStrings(envs *uint16) (err error) {
2154
	r1, _, e1 := syscall.SyscallN(procFreeEnvironmentStringsW.Addr(), uintptr(unsafe.Pointer(envs)))
2155
	if r1 == 0 {
2156
		err = errnoErr(e1)
2157
	}
2158
	return
2159
}
2160

2161
func FreeLibrary(handle Handle) (err error) {
2162
	r1, _, e1 := syscall.SyscallN(procFreeLibrary.Addr(), uintptr(handle))
2163
	if r1 == 0 {
2164
		err = errnoErr(e1)
2165
	}
2166
	return
2167
}
2168

2169
func GenerateConsoleCtrlEvent(ctrlEvent uint32, processGroupID uint32) (err error) {
2170
	r1, _, e1 := syscall.SyscallN(procGenerateConsoleCtrlEvent.Addr(), uintptr(ctrlEvent), uintptr(processGroupID))
2171
	if r1 == 0 {
2172
		err = errnoErr(e1)
2173
	}
2174
	return
2175
}
2176

2177
func GetACP() (acp uint32) {
2178
	r0, _, _ := syscall.SyscallN(procGetACP.Addr())
2179
	acp = uint32(r0)
2180
	return
2181
}
2182

2183
func GetActiveProcessorCount(groupNumber uint16) (ret uint32) {
2184
	r0, _, _ := syscall.SyscallN(procGetActiveProcessorCount.Addr(), uintptr(groupNumber))
2185
	ret = uint32(r0)
2186
	return
2187
}
2188

2189
func GetCommModemStatus(handle Handle, lpModemStat *uint32) (err error) {
2190
	r1, _, e1 := syscall.SyscallN(procGetCommModemStatus.Addr(), uintptr(handle), uintptr(unsafe.Pointer(lpModemStat)))
2191
	if r1 == 0 {
2192
		err = errnoErr(e1)
2193
	}
2194
	return
2195
}
2196

2197
func GetCommState(handle Handle, lpDCB *DCB) (err error) {
2198
	r1, _, e1 := syscall.SyscallN(procGetCommState.Addr(), uintptr(handle), uintptr(unsafe.Pointer(lpDCB)))
2199
	if r1 == 0 {
2200
		err = errnoErr(e1)
2201
	}
2202
	return
2203
}
2204

2205
func GetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error) {
2206
	r1, _, e1 := syscall.SyscallN(procGetCommTimeouts.Addr(), uintptr(handle), uintptr(unsafe.Pointer(timeouts)))
2207
	if r1 == 0 {
2208
		err = errnoErr(e1)
2209
	}
2210
	return
2211
}
2212

2213
func GetCommandLine() (cmd *uint16) {
2214
	r0, _, _ := syscall.SyscallN(procGetCommandLineW.Addr())
2215
	cmd = (*uint16)(unsafe.Pointer(r0))
2216
	return
2217
}
2218

2219
func GetComputerNameEx(nametype uint32, buf *uint16, n *uint32) (err error) {
2220
	r1, _, e1 := syscall.SyscallN(procGetComputerNameExW.Addr(), uintptr(nametype), uintptr(unsafe.Pointer(buf)), uintptr(unsafe.Pointer(n)))
2221
	if r1 == 0 {
2222
		err = errnoErr(e1)
2223
	}
2224
	return
2225
}
2226

2227
func GetComputerName(buf *uint16, n *uint32) (err error) {
2228
	r1, _, e1 := syscall.SyscallN(procGetComputerNameW.Addr(), uintptr(unsafe.Pointer(buf)), uintptr(unsafe.Pointer(n)))
2229
	if r1 == 0 {
2230
		err = errnoErr(e1)
2231
	}
2232
	return
2233
}
2234

2235
func GetConsoleCP() (cp uint32, err error) {
2236
	r0, _, e1 := syscall.SyscallN(procGetConsoleCP.Addr())
2237
	cp = uint32(r0)
2238
	if cp == 0 {
2239
		err = errnoErr(e1)
2240
	}
2241
	return
2242
}
2243

2244
func GetConsoleMode(console Handle, mode *uint32) (err error) {
2245
	r1, _, e1 := syscall.SyscallN(procGetConsoleMode.Addr(), uintptr(console), uintptr(unsafe.Pointer(mode)))
2246
	if r1 == 0 {
2247
		err = errnoErr(e1)
2248
	}
2249
	return
2250
}
2251

2252
func GetConsoleOutputCP() (cp uint32, err error) {
2253
	r0, _, e1 := syscall.SyscallN(procGetConsoleOutputCP.Addr())
2254
	cp = uint32(r0)
2255
	if cp == 0 {
2256
		err = errnoErr(e1)
2257
	}
2258
	return
2259
}
2260

2261
func GetConsoleScreenBufferInfo(console Handle, info *ConsoleScreenBufferInfo) (err error) {
2262
	r1, _, e1 := syscall.SyscallN(procGetConsoleScreenBufferInfo.Addr(), uintptr(console), uintptr(unsafe.Pointer(info)))
2263
	if r1 == 0 {
2264
		err = errnoErr(e1)
2265
	}
2266
	return
2267
}
2268

2269
func GetCurrentDirectory(buflen uint32, buf *uint16) (n uint32, err error) {
2270
	r0, _, e1 := syscall.SyscallN(procGetCurrentDirectoryW.Addr(), uintptr(buflen), uintptr(unsafe.Pointer(buf)))
2271
	n = uint32(r0)
2272
	if n == 0 {
2273
		err = errnoErr(e1)
2274
	}
2275
	return
2276
}
2277

2278
func GetCurrentProcessId() (pid uint32) {
2279
	r0, _, _ := syscall.SyscallN(procGetCurrentProcessId.Addr())
2280
	pid = uint32(r0)
2281
	return
2282
}
2283

2284
func GetCurrentThreadId() (id uint32) {
2285
	r0, _, _ := syscall.SyscallN(procGetCurrentThreadId.Addr())
2286
	id = uint32(r0)
2287
	return
2288
}
2289

2290
func GetDiskFreeSpaceEx(directoryName *uint16, freeBytesAvailableToCaller *uint64, totalNumberOfBytes *uint64, totalNumberOfFreeBytes *uint64) (err error) {
2291
	r1, _, e1 := syscall.SyscallN(procGetDiskFreeSpaceExW.Addr(), uintptr(unsafe.Pointer(directoryName)), uintptr(unsafe.Pointer(freeBytesAvailableToCaller)), uintptr(unsafe.Pointer(totalNumberOfBytes)), uintptr(unsafe.Pointer(totalNumberOfFreeBytes)))
2292
	if r1 == 0 {
2293
		err = errnoErr(e1)
2294
	}
2295
	return
2296
}
2297

2298
func GetDriveType(rootPathName *uint16) (driveType uint32) {
2299
	r0, _, _ := syscall.SyscallN(procGetDriveTypeW.Addr(), uintptr(unsafe.Pointer(rootPathName)))
2300
	driveType = uint32(r0)
2301
	return
2302
}
2303

2304
func GetEnvironmentStrings() (envs *uint16, err error) {
2305
	r0, _, e1 := syscall.SyscallN(procGetEnvironmentStringsW.Addr())
2306
	envs = (*uint16)(unsafe.Pointer(r0))
2307
	if envs == nil {
2308
		err = errnoErr(e1)
2309
	}
2310
	return
2311
}
2312

2313
func GetEnvironmentVariable(name *uint16, buffer *uint16, size uint32) (n uint32, err error) {
2314
	r0, _, e1 := syscall.SyscallN(procGetEnvironmentVariableW.Addr(), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(buffer)), uintptr(size))
2315
	n = uint32(r0)
2316
	if n == 0 {
2317
		err = errnoErr(e1)
2318
	}
2319
	return
2320
}
2321

2322
func GetExitCodeProcess(handle Handle, exitcode *uint32) (err error) {
2323
	r1, _, e1 := syscall.SyscallN(procGetExitCodeProcess.Addr(), uintptr(handle), uintptr(unsafe.Pointer(exitcode)))
2324
	if r1 == 0 {
2325
		err = errnoErr(e1)
2326
	}
2327
	return
2328
}
2329

2330
func GetFileAttributesEx(name *uint16, level uint32, info *byte) (err error) {
2331
	r1, _, e1 := syscall.SyscallN(procGetFileAttributesExW.Addr(), uintptr(unsafe.Pointer(name)), uintptr(level), uintptr(unsafe.Pointer(info)))
2332
	if r1 == 0 {
2333
		err = errnoErr(e1)
2334
	}
2335
	return
2336
}
2337

2338
func GetFileAttributes(name *uint16) (attrs uint32, err error) {
2339
	r0, _, e1 := syscall.SyscallN(procGetFileAttributesW.Addr(), uintptr(unsafe.Pointer(name)))
2340
	attrs = uint32(r0)
2341
	if attrs == INVALID_FILE_ATTRIBUTES {
2342
		err = errnoErr(e1)
2343
	}
2344
	return
2345
}
2346

2347
func GetFileInformationByHandle(handle Handle, data *ByHandleFileInformation) (err error) {
2348
	r1, _, e1 := syscall.SyscallN(procGetFileInformationByHandle.Addr(), uintptr(handle), uintptr(unsafe.Pointer(data)))
2349
	if r1 == 0 {
2350
		err = errnoErr(e1)
2351
	}
2352
	return
2353
}
2354

2355
func GetFileInformationByHandleEx(handle Handle, class uint32, outBuffer *byte, outBufferLen uint32) (err error) {
2356
	r1, _, e1 := syscall.SyscallN(procGetFileInformationByHandleEx.Addr(), uintptr(handle), uintptr(class), uintptr(unsafe.Pointer(outBuffer)), uintptr(outBufferLen))
2357
	if r1 == 0 {
2358
		err = errnoErr(e1)
2359
	}
2360
	return
2361
}
2362

2363
func GetFileTime(handle Handle, ctime *Filetime, atime *Filetime, wtime *Filetime) (err error) {
2364
	r1, _, e1 := syscall.SyscallN(procGetFileTime.Addr(), uintptr(handle), uintptr(unsafe.Pointer(ctime)), uintptr(unsafe.Pointer(atime)), uintptr(unsafe.Pointer(wtime)))
2365
	if r1 == 0 {
2366
		err = errnoErr(e1)
2367
	}
2368
	return
2369
}
2370

2371
func GetFileType(filehandle Handle) (n uint32, err error) {
2372
	r0, _, e1 := syscall.SyscallN(procGetFileType.Addr(), uintptr(filehandle))
2373
	n = uint32(r0)
2374
	if n == 0 {
2375
		err = errnoErr(e1)
2376
	}
2377
	return
2378
}
2379

2380
func GetFinalPathNameByHandle(file Handle, filePath *uint16, filePathSize uint32, flags uint32) (n uint32, err error) {
2381
	r0, _, e1 := syscall.SyscallN(procGetFinalPathNameByHandleW.Addr(), uintptr(file), uintptr(unsafe.Pointer(filePath)), uintptr(filePathSize), uintptr(flags))
2382
	n = uint32(r0)
2383
	if n == 0 {
2384
		err = errnoErr(e1)
2385
	}
2386
	return
2387
}
2388

2389
func GetFullPathName(path *uint16, buflen uint32, buf *uint16, fname **uint16) (n uint32, err error) {
2390
	r0, _, e1 := syscall.SyscallN(procGetFullPathNameW.Addr(), uintptr(unsafe.Pointer(path)), uintptr(buflen), uintptr(unsafe.Pointer(buf)), uintptr(unsafe.Pointer(fname)))
2391
	n = uint32(r0)
2392
	if n == 0 {
2393
		err = errnoErr(e1)
2394
	}
2395
	return
2396
}
2397

2398
func GetLargePageMinimum() (size uintptr) {
2399
	r0, _, _ := syscall.SyscallN(procGetLargePageMinimum.Addr())
2400
	size = uintptr(r0)
2401
	return
2402
}
2403

2404
func GetLastError() (lasterr error) {
2405
	r0, _, _ := syscall.SyscallN(procGetLastError.Addr())
2406
	if r0 != 0 {
2407
		lasterr = syscall.Errno(r0)
2408
	}
2409
	return
2410
}
2411

2412
func GetLogicalDriveStrings(bufferLength uint32, buffer *uint16) (n uint32, err error) {
2413
	r0, _, e1 := syscall.SyscallN(procGetLogicalDriveStringsW.Addr(), uintptr(bufferLength), uintptr(unsafe.Pointer(buffer)))
2414
	n = uint32(r0)
2415
	if n == 0 {
2416
		err = errnoErr(e1)
2417
	}
2418
	return
2419
}
2420

2421
func GetLogicalDrives() (drivesBitMask uint32, err error) {
2422
	r0, _, e1 := syscall.SyscallN(procGetLogicalDrives.Addr())
2423
	drivesBitMask = uint32(r0)
2424
	if drivesBitMask == 0 {
2425
		err = errnoErr(e1)
2426
	}
2427
	return
2428
}
2429

2430
func GetLongPathName(path *uint16, buf *uint16, buflen uint32) (n uint32, err error) {
2431
	r0, _, e1 := syscall.SyscallN(procGetLongPathNameW.Addr(), uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(buf)), uintptr(buflen))
2432
	n = uint32(r0)
2433
	if n == 0 {
2434
		err = errnoErr(e1)
2435
	}
2436
	return
2437
}
2438

2439
func GetMaximumProcessorCount(groupNumber uint16) (ret uint32) {
2440
	r0, _, _ := syscall.SyscallN(procGetMaximumProcessorCount.Addr(), uintptr(groupNumber))
2441
	ret = uint32(r0)
2442
	return
2443
}
2444

2445
func GetModuleFileName(module Handle, filename *uint16, size uint32) (n uint32, err error) {
2446
	r0, _, e1 := syscall.SyscallN(procGetModuleFileNameW.Addr(), uintptr(module), uintptr(unsafe.Pointer(filename)), uintptr(size))
2447
	n = uint32(r0)
2448
	if n == 0 {
2449
		err = errnoErr(e1)
2450
	}
2451
	return
2452
}
2453

2454
func GetModuleHandleEx(flags uint32, moduleName *uint16, module *Handle) (err error) {
2455
	r1, _, e1 := syscall.SyscallN(procGetModuleHandleExW.Addr(), uintptr(flags), uintptr(unsafe.Pointer(moduleName)), uintptr(unsafe.Pointer(module)))
2456
	if r1 == 0 {
2457
		err = errnoErr(e1)
2458
	}
2459
	return
2460
}
2461

2462
func GetNamedPipeClientProcessId(pipe Handle, clientProcessID *uint32) (err error) {
2463
	r1, _, e1 := syscall.SyscallN(procGetNamedPipeClientProcessId.Addr(), uintptr(pipe), uintptr(unsafe.Pointer(clientProcessID)))
2464
	if r1 == 0 {
2465
		err = errnoErr(e1)
2466
	}
2467
	return
2468
}
2469

2470
func GetNamedPipeHandleState(pipe Handle, state *uint32, curInstances *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32, userName *uint16, maxUserNameSize uint32) (err error) {
2471
	r1, _, e1 := syscall.SyscallN(procGetNamedPipeHandleStateW.Addr(), uintptr(pipe), uintptr(unsafe.Pointer(state)), uintptr(unsafe.Pointer(curInstances)), uintptr(unsafe.Pointer(maxCollectionCount)), uintptr(unsafe.Pointer(collectDataTimeout)), uintptr(unsafe.Pointer(userName)), uintptr(maxUserNameSize))
2472
	if r1 == 0 {
2473
		err = errnoErr(e1)
2474
	}
2475
	return
2476
}
2477

2478
func GetNamedPipeInfo(pipe Handle, flags *uint32, outSize *uint32, inSize *uint32, maxInstances *uint32) (err error) {
2479
	r1, _, e1 := syscall.SyscallN(procGetNamedPipeInfo.Addr(), uintptr(pipe), uintptr(unsafe.Pointer(flags)), uintptr(unsafe.Pointer(outSize)), uintptr(unsafe.Pointer(inSize)), uintptr(unsafe.Pointer(maxInstances)))
2480
	if r1 == 0 {
2481
		err = errnoErr(e1)
2482
	}
2483
	return
2484
}
2485

2486
func GetNamedPipeServerProcessId(pipe Handle, serverProcessID *uint32) (err error) {
2487
	r1, _, e1 := syscall.SyscallN(procGetNamedPipeServerProcessId.Addr(), uintptr(pipe), uintptr(unsafe.Pointer(serverProcessID)))
2488
	if r1 == 0 {
2489
		err = errnoErr(e1)
2490
	}
2491
	return
2492
}
2493

2494
func GetNumberOfConsoleInputEvents(console Handle, numevents *uint32) (err error) {
2495
	r1, _, e1 := syscall.SyscallN(procGetNumberOfConsoleInputEvents.Addr(), uintptr(console), uintptr(unsafe.Pointer(numevents)))
2496
	if r1 == 0 {
2497
		err = errnoErr(e1)
2498
	}
2499
	return
2500
}
2501

2502
func GetOverlappedResult(handle Handle, overlapped *Overlapped, done *uint32, wait bool) (err error) {
2503
	var _p0 uint32
2504
	if wait {
2505
		_p0 = 1
2506
	}
2507
	r1, _, e1 := syscall.SyscallN(procGetOverlappedResult.Addr(), uintptr(handle), uintptr(unsafe.Pointer(overlapped)), uintptr(unsafe.Pointer(done)), uintptr(_p0))
2508
	if r1 == 0 {
2509
		err = errnoErr(e1)
2510
	}
2511
	return
2512
}
2513

2514
func GetPriorityClass(process Handle) (ret uint32, err error) {
2515
	r0, _, e1 := syscall.SyscallN(procGetPriorityClass.Addr(), uintptr(process))
2516
	ret = uint32(r0)
2517
	if ret == 0 {
2518
		err = errnoErr(e1)
2519
	}
2520
	return
2521
}
2522

2523
func GetProcAddress(module Handle, procname string) (proc uintptr, err error) {
2524
	var _p0 *byte
2525
	_p0, err = syscall.BytePtrFromString(procname)
2526
	if err != nil {
2527
		return
2528
	}
2529
	return _GetProcAddress(module, _p0)
2530
}
2531

2532
func _GetProcAddress(module Handle, procname *byte) (proc uintptr, err error) {
2533
	r0, _, e1 := syscall.SyscallN(procGetProcAddress.Addr(), uintptr(module), uintptr(unsafe.Pointer(procname)))
2534
	proc = uintptr(r0)
2535
	if proc == 0 {
2536
		err = errnoErr(e1)
2537
	}
2538
	return
2539
}
2540

2541
func GetProcessId(process Handle) (id uint32, err error) {
2542
	r0, _, e1 := syscall.SyscallN(procGetProcessId.Addr(), uintptr(process))
2543
	id = uint32(r0)
2544
	if id == 0 {
2545
		err = errnoErr(e1)
2546
	}
2547
	return
2548
}
2549

2550
func getProcessPreferredUILanguages(flags uint32, numLanguages *uint32, buf *uint16, bufSize *uint32) (err error) {
2551
	r1, _, e1 := syscall.SyscallN(procGetProcessPreferredUILanguages.Addr(), uintptr(flags), uintptr(unsafe.Pointer(numLanguages)), uintptr(unsafe.Pointer(buf)), uintptr(unsafe.Pointer(bufSize)))
2552
	if r1 == 0 {
2553
		err = errnoErr(e1)
2554
	}
2555
	return
2556
}
2557

2558
func GetProcessShutdownParameters(level *uint32, flags *uint32) (err error) {
2559
	r1, _, e1 := syscall.SyscallN(procGetProcessShutdownParameters.Addr(), uintptr(unsafe.Pointer(level)), uintptr(unsafe.Pointer(flags)))
2560
	if r1 == 0 {
2561
		err = errnoErr(e1)
2562
	}
2563
	return
2564
}
2565

2566
func GetProcessTimes(handle Handle, creationTime *Filetime, exitTime *Filetime, kernelTime *Filetime, userTime *Filetime) (err error) {
2567
	r1, _, e1 := syscall.SyscallN(procGetProcessTimes.Addr(), uintptr(handle), uintptr(unsafe.Pointer(creationTime)), uintptr(unsafe.Pointer(exitTime)), uintptr(unsafe.Pointer(kernelTime)), uintptr(unsafe.Pointer(userTime)))
2568
	if r1 == 0 {
2569
		err = errnoErr(e1)
2570
	}
2571
	return
2572
}
2573

2574
func GetProcessWorkingSetSizeEx(hProcess Handle, lpMinimumWorkingSetSize *uintptr, lpMaximumWorkingSetSize *uintptr, flags *uint32) {
2575
	syscall.SyscallN(procGetProcessWorkingSetSizeEx.Addr(), uintptr(hProcess), uintptr(unsafe.Pointer(lpMinimumWorkingSetSize)), uintptr(unsafe.Pointer(lpMaximumWorkingSetSize)), uintptr(unsafe.Pointer(flags)))
2576
	return
2577
}
2578

2579
func GetQueuedCompletionStatus(cphandle Handle, qty *uint32, key *uintptr, overlapped **Overlapped, timeout uint32) (err error) {
2580
	r1, _, e1 := syscall.SyscallN(procGetQueuedCompletionStatus.Addr(), uintptr(cphandle), uintptr(unsafe.Pointer(qty)), uintptr(unsafe.Pointer(key)), uintptr(unsafe.Pointer(overlapped)), uintptr(timeout))
2581
	if r1 == 0 {
2582
		err = errnoErr(e1)
2583
	}
2584
	return
2585
}
2586

2587
func GetShortPathName(longpath *uint16, shortpath *uint16, buflen uint32) (n uint32, err error) {
2588
	r0, _, e1 := syscall.SyscallN(procGetShortPathNameW.Addr(), uintptr(unsafe.Pointer(longpath)), uintptr(unsafe.Pointer(shortpath)), uintptr(buflen))
2589
	n = uint32(r0)
2590
	if n == 0 {
2591
		err = errnoErr(e1)
2592
	}
2593
	return
2594
}
2595

2596
func getStartupInfo(startupInfo *StartupInfo) {
2597
	syscall.SyscallN(procGetStartupInfoW.Addr(), uintptr(unsafe.Pointer(startupInfo)))
2598
	return
2599
}
2600

2601
func GetStdHandle(stdhandle uint32) (handle Handle, err error) {
2602
	r0, _, e1 := syscall.SyscallN(procGetStdHandle.Addr(), uintptr(stdhandle))
2603
	handle = Handle(r0)
2604
	if handle == InvalidHandle {
2605
		err = errnoErr(e1)
2606
	}
2607
	return
2608
}
2609

2610
func getSystemDirectory(dir *uint16, dirLen uint32) (len uint32, err error) {
2611
	r0, _, e1 := syscall.SyscallN(procGetSystemDirectoryW.Addr(), uintptr(unsafe.Pointer(dir)), uintptr(dirLen))
2612
	len = uint32(r0)
2613
	if len == 0 {
2614
		err = errnoErr(e1)
2615
	}
2616
	return
2617
}
2618

2619
func getSystemPreferredUILanguages(flags uint32, numLanguages *uint32, buf *uint16, bufSize *uint32) (err error) {
2620
	r1, _, e1 := syscall.SyscallN(procGetSystemPreferredUILanguages.Addr(), uintptr(flags), uintptr(unsafe.Pointer(numLanguages)), uintptr(unsafe.Pointer(buf)), uintptr(unsafe.Pointer(bufSize)))
2621
	if r1 == 0 {
2622
		err = errnoErr(e1)
2623
	}
2624
	return
2625
}
2626

2627
func GetSystemTimeAsFileTime(time *Filetime) {
2628
	syscall.SyscallN(procGetSystemTimeAsFileTime.Addr(), uintptr(unsafe.Pointer(time)))
2629
	return
2630
}
2631

2632
func GetSystemTimePreciseAsFileTime(time *Filetime) {
2633
	syscall.SyscallN(procGetSystemTimePreciseAsFileTime.Addr(), uintptr(unsafe.Pointer(time)))
2634
	return
2635
}
2636

2637
func getSystemWindowsDirectory(dir *uint16, dirLen uint32) (len uint32, err error) {
2638
	r0, _, e1 := syscall.SyscallN(procGetSystemWindowsDirectoryW.Addr(), uintptr(unsafe.Pointer(dir)), uintptr(dirLen))
2639
	len = uint32(r0)
2640
	if len == 0 {
2641
		err = errnoErr(e1)
2642
	}
2643
	return
2644
}
2645

2646
func GetTempPath(buflen uint32, buf *uint16) (n uint32, err error) {
2647
	r0, _, e1 := syscall.SyscallN(procGetTempPathW.Addr(), uintptr(buflen), uintptr(unsafe.Pointer(buf)))
2648
	n = uint32(r0)
2649
	if n == 0 {
2650
		err = errnoErr(e1)
2651
	}
2652
	return
2653
}
2654

2655
func getThreadPreferredUILanguages(flags uint32, numLanguages *uint32, buf *uint16, bufSize *uint32) (err error) {
2656
	r1, _, e1 := syscall.SyscallN(procGetThreadPreferredUILanguages.Addr(), uintptr(flags), uintptr(unsafe.Pointer(numLanguages)), uintptr(unsafe.Pointer(buf)), uintptr(unsafe.Pointer(bufSize)))
2657
	if r1 == 0 {
2658
		err = errnoErr(e1)
2659
	}
2660
	return
2661
}
2662

2663
func getTickCount64() (ms uint64) {
2664
	r0, _, _ := syscall.SyscallN(procGetTickCount64.Addr())
2665
	ms = uint64(r0)
2666
	return
2667
}
2668

2669
func GetTimeZoneInformation(tzi *Timezoneinformation) (rc uint32, err error) {
2670
	r0, _, e1 := syscall.SyscallN(procGetTimeZoneInformation.Addr(), uintptr(unsafe.Pointer(tzi)))
2671
	rc = uint32(r0)
2672
	if rc == 0xffffffff {
2673
		err = errnoErr(e1)
2674
	}
2675
	return
2676
}
2677

2678
func getUserPreferredUILanguages(flags uint32, numLanguages *uint32, buf *uint16, bufSize *uint32) (err error) {
2679
	r1, _, e1 := syscall.SyscallN(procGetUserPreferredUILanguages.Addr(), uintptr(flags), uintptr(unsafe.Pointer(numLanguages)), uintptr(unsafe.Pointer(buf)), uintptr(unsafe.Pointer(bufSize)))
2680
	if r1 == 0 {
2681
		err = errnoErr(e1)
2682
	}
2683
	return
2684
}
2685

2686
func GetVersion() (ver uint32, err error) {
2687
	r0, _, e1 := syscall.SyscallN(procGetVersion.Addr())
2688
	ver = uint32(r0)
2689
	if ver == 0 {
2690
		err = errnoErr(e1)
2691
	}
2692
	return
2693
}
2694

2695
func GetVolumeInformationByHandle(file Handle, volumeNameBuffer *uint16, volumeNameSize uint32, volumeNameSerialNumber *uint32, maximumComponentLength *uint32, fileSystemFlags *uint32, fileSystemNameBuffer *uint16, fileSystemNameSize uint32) (err error) {
2696
	r1, _, e1 := syscall.SyscallN(procGetVolumeInformationByHandleW.Addr(), uintptr(file), uintptr(unsafe.Pointer(volumeNameBuffer)), uintptr(volumeNameSize), uintptr(unsafe.Pointer(volumeNameSerialNumber)), uintptr(unsafe.Pointer(maximumComponentLength)), uintptr(unsafe.Pointer(fileSystemFlags)), uintptr(unsafe.Pointer(fileSystemNameBuffer)), uintptr(fileSystemNameSize))
2697
	if r1 == 0 {
2698
		err = errnoErr(e1)
2699
	}
2700
	return
2701
}
2702

2703
func GetVolumeInformation(rootPathName *uint16, volumeNameBuffer *uint16, volumeNameSize uint32, volumeNameSerialNumber *uint32, maximumComponentLength *uint32, fileSystemFlags *uint32, fileSystemNameBuffer *uint16, fileSystemNameSize uint32) (err error) {
2704
	r1, _, e1 := syscall.SyscallN(procGetVolumeInformationW.Addr(), uintptr(unsafe.Pointer(rootPathName)), uintptr(unsafe.Pointer(volumeNameBuffer)), uintptr(volumeNameSize), uintptr(unsafe.Pointer(volumeNameSerialNumber)), uintptr(unsafe.Pointer(maximumComponentLength)), uintptr(unsafe.Pointer(fileSystemFlags)), uintptr(unsafe.Pointer(fileSystemNameBuffer)), uintptr(fileSystemNameSize))
2705
	if r1 == 0 {
2706
		err = errnoErr(e1)
2707
	}
2708
	return
2709
}
2710

2711
func GetVolumeNameForVolumeMountPoint(volumeMountPoint *uint16, volumeName *uint16, bufferlength uint32) (err error) {
2712
	r1, _, e1 := syscall.SyscallN(procGetVolumeNameForVolumeMountPointW.Addr(), uintptr(unsafe.Pointer(volumeMountPoint)), uintptr(unsafe.Pointer(volumeName)), uintptr(bufferlength))
2713
	if r1 == 0 {
2714
		err = errnoErr(e1)
2715
	}
2716
	return
2717
}
2718

2719
func GetVolumePathName(fileName *uint16, volumePathName *uint16, bufferLength uint32) (err error) {
2720
	r1, _, e1 := syscall.SyscallN(procGetVolumePathNameW.Addr(), uintptr(unsafe.Pointer(fileName)), uintptr(unsafe.Pointer(volumePathName)), uintptr(bufferLength))
2721
	if r1 == 0 {
2722
		err = errnoErr(e1)
2723
	}
2724
	return
2725
}
2726

2727
func GetVolumePathNamesForVolumeName(volumeName *uint16, volumePathNames *uint16, bufferLength uint32, returnLength *uint32) (err error) {
2728
	r1, _, e1 := syscall.SyscallN(procGetVolumePathNamesForVolumeNameW.Addr(), uintptr(unsafe.Pointer(volumeName)), uintptr(unsafe.Pointer(volumePathNames)), uintptr(bufferLength), uintptr(unsafe.Pointer(returnLength)))
2729
	if r1 == 0 {
2730
		err = errnoErr(e1)
2731
	}
2732
	return
2733
}
2734

2735
func getWindowsDirectory(dir *uint16, dirLen uint32) (len uint32, err error) {
2736
	r0, _, e1 := syscall.SyscallN(procGetWindowsDirectoryW.Addr(), uintptr(unsafe.Pointer(dir)), uintptr(dirLen))
2737
	len = uint32(r0)
2738
	if len == 0 {
2739
		err = errnoErr(e1)
2740
	}
2741
	return
2742
}
2743

2744
func initializeProcThreadAttributeList(attrlist *ProcThreadAttributeList, attrcount uint32, flags uint32, size *uintptr) (err error) {
2745
	r1, _, e1 := syscall.SyscallN(procInitializeProcThreadAttributeList.Addr(), uintptr(unsafe.Pointer(attrlist)), uintptr(attrcount), uintptr(flags), uintptr(unsafe.Pointer(size)))
2746
	if r1 == 0 {
2747
		err = errnoErr(e1)
2748
	}
2749
	return
2750
}
2751

2752
func IsWow64Process(handle Handle, isWow64 *bool) (err error) {
2753
	var _p0 uint32
2754
	if *isWow64 {
2755
		_p0 = 1
2756
	}
2757
	r1, _, e1 := syscall.SyscallN(procIsWow64Process.Addr(), uintptr(handle), uintptr(unsafe.Pointer(&_p0)))
2758
	*isWow64 = _p0 != 0
2759
	if r1 == 0 {
2760
		err = errnoErr(e1)
2761
	}
2762
	return
2763
}
2764

2765
func IsWow64Process2(handle Handle, processMachine *uint16, nativeMachine *uint16) (err error) {
2766
	err = procIsWow64Process2.Find()
2767
	if err != nil {
2768
		return
2769
	}
2770
	r1, _, e1 := syscall.SyscallN(procIsWow64Process2.Addr(), uintptr(handle), uintptr(unsafe.Pointer(processMachine)), uintptr(unsafe.Pointer(nativeMachine)))
2771
	if r1 == 0 {
2772
		err = errnoErr(e1)
2773
	}
2774
	return
2775
}
2776

2777
func LoadLibraryEx(libname string, zero Handle, flags uintptr) (handle Handle, err error) {
2778
	var _p0 *uint16
2779
	_p0, err = syscall.UTF16PtrFromString(libname)
2780
	if err != nil {
2781
		return
2782
	}
2783
	return _LoadLibraryEx(_p0, zero, flags)
2784
}
2785

2786
func _LoadLibraryEx(libname *uint16, zero Handle, flags uintptr) (handle Handle, err error) {
2787
	r0, _, e1 := syscall.SyscallN(procLoadLibraryExW.Addr(), uintptr(unsafe.Pointer(libname)), uintptr(zero), uintptr(flags))
2788
	handle = Handle(r0)
2789
	if handle == 0 {
2790
		err = errnoErr(e1)
2791
	}
2792
	return
2793
}
2794

2795
func LoadLibrary(libname string) (handle Handle, err error) {
2796
	var _p0 *uint16
2797
	_p0, err = syscall.UTF16PtrFromString(libname)
2798
	if err != nil {
2799
		return
2800
	}
2801
	return _LoadLibrary(_p0)
2802
}
2803

2804
func _LoadLibrary(libname *uint16) (handle Handle, err error) {
2805
	r0, _, e1 := syscall.SyscallN(procLoadLibraryW.Addr(), uintptr(unsafe.Pointer(libname)))
2806
	handle = Handle(r0)
2807
	if handle == 0 {
2808
		err = errnoErr(e1)
2809
	}
2810
	return
2811
}
2812

2813
func LoadResource(module Handle, resInfo Handle) (resData Handle, err error) {
2814
	r0, _, e1 := syscall.SyscallN(procLoadResource.Addr(), uintptr(module), uintptr(resInfo))
2815
	resData = Handle(r0)
2816
	if resData == 0 {
2817
		err = errnoErr(e1)
2818
	}
2819
	return
2820
}
2821

2822
func LocalAlloc(flags uint32, length uint32) (ptr uintptr, err error) {
2823
	r0, _, e1 := syscall.SyscallN(procLocalAlloc.Addr(), uintptr(flags), uintptr(length))
2824
	ptr = uintptr(r0)
2825
	if ptr == 0 {
2826
		err = errnoErr(e1)
2827
	}
2828
	return
2829
}
2830

2831
func LocalFree(hmem Handle) (handle Handle, err error) {
2832
	r0, _, e1 := syscall.SyscallN(procLocalFree.Addr(), uintptr(hmem))
2833
	handle = Handle(r0)
2834
	if handle != 0 {
2835
		err = errnoErr(e1)
2836
	}
2837
	return
2838
}
2839

2840
func LockFileEx(file Handle, flags uint32, reserved uint32, bytesLow uint32, bytesHigh uint32, overlapped *Overlapped) (err error) {
2841
	r1, _, e1 := syscall.SyscallN(procLockFileEx.Addr(), uintptr(file), uintptr(flags), uintptr(reserved), uintptr(bytesLow), uintptr(bytesHigh), uintptr(unsafe.Pointer(overlapped)))
2842
	if r1 == 0 {
2843
		err = errnoErr(e1)
2844
	}
2845
	return
2846
}
2847

2848
func LockResource(resData Handle) (addr uintptr, err error) {
2849
	r0, _, e1 := syscall.SyscallN(procLockResource.Addr(), uintptr(resData))
2850
	addr = uintptr(r0)
2851
	if addr == 0 {
2852
		err = errnoErr(e1)
2853
	}
2854
	return
2855
}
2856

2857
func MapViewOfFile(handle Handle, access uint32, offsetHigh uint32, offsetLow uint32, length uintptr) (addr uintptr, err error) {
2858
	r0, _, e1 := syscall.SyscallN(procMapViewOfFile.Addr(), uintptr(handle), uintptr(access), uintptr(offsetHigh), uintptr(offsetLow), uintptr(length))
2859
	addr = uintptr(r0)
2860
	if addr == 0 {
2861
		err = errnoErr(e1)
2862
	}
2863
	return
2864
}
2865

2866
func Module32First(snapshot Handle, moduleEntry *ModuleEntry32) (err error) {
2867
	r1, _, e1 := syscall.SyscallN(procModule32FirstW.Addr(), uintptr(snapshot), uintptr(unsafe.Pointer(moduleEntry)))
2868
	if r1 == 0 {
2869
		err = errnoErr(e1)
2870
	}
2871
	return
2872
}
2873

2874
func Module32Next(snapshot Handle, moduleEntry *ModuleEntry32) (err error) {
2875
	r1, _, e1 := syscall.SyscallN(procModule32NextW.Addr(), uintptr(snapshot), uintptr(unsafe.Pointer(moduleEntry)))
2876
	if r1 == 0 {
2877
		err = errnoErr(e1)
2878
	}
2879
	return
2880
}
2881

2882
func MoveFileEx(from *uint16, to *uint16, flags uint32) (err error) {
2883
	r1, _, e1 := syscall.SyscallN(procMoveFileExW.Addr(), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(to)), uintptr(flags))
2884
	if r1 == 0 {
2885
		err = errnoErr(e1)
2886
	}
2887
	return
2888
}
2889

2890
func MoveFile(from *uint16, to *uint16) (err error) {
2891
	r1, _, e1 := syscall.SyscallN(procMoveFileW.Addr(), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(to)))
2892
	if r1 == 0 {
2893
		err = errnoErr(e1)
2894
	}
2895
	return
2896
}
2897

2898
func MultiByteToWideChar(codePage uint32, dwFlags uint32, str *byte, nstr int32, wchar *uint16, nwchar int32) (nwrite int32, err error) {
2899
	r0, _, e1 := syscall.SyscallN(procMultiByteToWideChar.Addr(), uintptr(codePage), uintptr(dwFlags), uintptr(unsafe.Pointer(str)), uintptr(nstr), uintptr(unsafe.Pointer(wchar)), uintptr(nwchar))
2900
	nwrite = int32(r0)
2901
	if nwrite == 0 {
2902
		err = errnoErr(e1)
2903
	}
2904
	return
2905
}
2906

2907
func OpenEvent(desiredAccess uint32, inheritHandle bool, name *uint16) (handle Handle, err error) {
2908
	var _p0 uint32
2909
	if inheritHandle {
2910
		_p0 = 1
2911
	}
2912
	r0, _, e1 := syscall.SyscallN(procOpenEventW.Addr(), uintptr(desiredAccess), uintptr(_p0), uintptr(unsafe.Pointer(name)))
2913
	handle = Handle(r0)
2914
	if handle == 0 {
2915
		err = errnoErr(e1)
2916
	}
2917
	return
2918
}
2919

2920
func OpenMutex(desiredAccess uint32, inheritHandle bool, name *uint16) (handle Handle, err error) {
2921
	var _p0 uint32
2922
	if inheritHandle {
2923
		_p0 = 1
2924
	}
2925
	r0, _, e1 := syscall.SyscallN(procOpenMutexW.Addr(), uintptr(desiredAccess), uintptr(_p0), uintptr(unsafe.Pointer(name)))
2926
	handle = Handle(r0)
2927
	if handle == 0 {
2928
		err = errnoErr(e1)
2929
	}
2930
	return
2931
}
2932

2933
func OpenProcess(desiredAccess uint32, inheritHandle bool, processId uint32) (handle Handle, err error) {
2934
	var _p0 uint32
2935
	if inheritHandle {
2936
		_p0 = 1
2937
	}
2938
	r0, _, e1 := syscall.SyscallN(procOpenProcess.Addr(), uintptr(desiredAccess), uintptr(_p0), uintptr(processId))
2939
	handle = Handle(r0)
2940
	if handle == 0 {
2941
		err = errnoErr(e1)
2942
	}
2943
	return
2944
}
2945

2946
func OpenThread(desiredAccess uint32, inheritHandle bool, threadId uint32) (handle Handle, err error) {
2947
	var _p0 uint32
2948
	if inheritHandle {
2949
		_p0 = 1
2950
	}
2951
	r0, _, e1 := syscall.SyscallN(procOpenThread.Addr(), uintptr(desiredAccess), uintptr(_p0), uintptr(threadId))
2952
	handle = Handle(r0)
2953
	if handle == 0 {
2954
		err = errnoErr(e1)
2955
	}
2956
	return
2957
}
2958

2959
func PostQueuedCompletionStatus(cphandle Handle, qty uint32, key uintptr, overlapped *Overlapped) (err error) {
2960
	r1, _, e1 := syscall.SyscallN(procPostQueuedCompletionStatus.Addr(), uintptr(cphandle), uintptr(qty), uintptr(key), uintptr(unsafe.Pointer(overlapped)))
2961
	if r1 == 0 {
2962
		err = errnoErr(e1)
2963
	}
2964
	return
2965
}
2966

2967
func Process32First(snapshot Handle, procEntry *ProcessEntry32) (err error) {
2968
	r1, _, e1 := syscall.SyscallN(procProcess32FirstW.Addr(), uintptr(snapshot), uintptr(unsafe.Pointer(procEntry)))
2969
	if r1 == 0 {
2970
		err = errnoErr(e1)
2971
	}
2972
	return
2973
}
2974

2975
func Process32Next(snapshot Handle, procEntry *ProcessEntry32) (err error) {
2976
	r1, _, e1 := syscall.SyscallN(procProcess32NextW.Addr(), uintptr(snapshot), uintptr(unsafe.Pointer(procEntry)))
2977
	if r1 == 0 {
2978
		err = errnoErr(e1)
2979
	}
2980
	return
2981
}
2982

2983
func ProcessIdToSessionId(pid uint32, sessionid *uint32) (err error) {
2984
	r1, _, e1 := syscall.SyscallN(procProcessIdToSessionId.Addr(), uintptr(pid), uintptr(unsafe.Pointer(sessionid)))
2985
	if r1 == 0 {
2986
		err = errnoErr(e1)
2987
	}
2988
	return
2989
}
2990

2991
func PulseEvent(event Handle) (err error) {
2992
	r1, _, e1 := syscall.SyscallN(procPulseEvent.Addr(), uintptr(event))
2993
	if r1 == 0 {
2994
		err = errnoErr(e1)
2995
	}
2996
	return
2997
}
2998

2999
func PurgeComm(handle Handle, dwFlags uint32) (err error) {
3000
	r1, _, e1 := syscall.SyscallN(procPurgeComm.Addr(), uintptr(handle), uintptr(dwFlags))
3001
	if r1 == 0 {
3002
		err = errnoErr(e1)
3003
	}
3004
	return
3005
}
3006

3007
func QueryDosDevice(deviceName *uint16, targetPath *uint16, max uint32) (n uint32, err error) {
3008
	r0, _, e1 := syscall.SyscallN(procQueryDosDeviceW.Addr(), uintptr(unsafe.Pointer(deviceName)), uintptr(unsafe.Pointer(targetPath)), uintptr(max))
3009
	n = uint32(r0)
3010
	if n == 0 {
3011
		err = errnoErr(e1)
3012
	}
3013
	return
3014
}
3015

3016
func QueryFullProcessImageName(proc Handle, flags uint32, exeName *uint16, size *uint32) (err error) {
3017
	r1, _, e1 := syscall.SyscallN(procQueryFullProcessImageNameW.Addr(), uintptr(proc), uintptr(flags), uintptr(unsafe.Pointer(exeName)), uintptr(unsafe.Pointer(size)))
3018
	if r1 == 0 {
3019
		err = errnoErr(e1)
3020
	}
3021
	return
3022
}
3023

3024
func QueryInformationJobObject(job Handle, JobObjectInformationClass int32, JobObjectInformation uintptr, JobObjectInformationLength uint32, retlen *uint32) (err error) {
3025
	r1, _, e1 := syscall.SyscallN(procQueryInformationJobObject.Addr(), uintptr(job), uintptr(JobObjectInformationClass), uintptr(JobObjectInformation), uintptr(JobObjectInformationLength), uintptr(unsafe.Pointer(retlen)))
3026
	if r1 == 0 {
3027
		err = errnoErr(e1)
3028
	}
3029
	return
3030
}
3031

3032
func ReadConsole(console Handle, buf *uint16, toread uint32, read *uint32, inputControl *byte) (err error) {
3033
	r1, _, e1 := syscall.SyscallN(procReadConsoleW.Addr(), uintptr(console), uintptr(unsafe.Pointer(buf)), uintptr(toread), uintptr(unsafe.Pointer(read)), uintptr(unsafe.Pointer(inputControl)))
3034
	if r1 == 0 {
3035
		err = errnoErr(e1)
3036
	}
3037
	return
3038
}
3039

3040
func ReadDirectoryChanges(handle Handle, buf *byte, buflen uint32, watchSubTree bool, mask uint32, retlen *uint32, overlapped *Overlapped, completionRoutine uintptr) (err error) {
3041
	var _p0 uint32
3042
	if watchSubTree {
3043
		_p0 = 1
3044
	}
3045
	r1, _, e1 := syscall.SyscallN(procReadDirectoryChangesW.Addr(), uintptr(handle), uintptr(unsafe.Pointer(buf)), uintptr(buflen), uintptr(_p0), uintptr(mask), uintptr(unsafe.Pointer(retlen)), uintptr(unsafe.Pointer(overlapped)), uintptr(completionRoutine))
3046
	if r1 == 0 {
3047
		err = errnoErr(e1)
3048
	}
3049
	return
3050
}
3051

3052
func readFile(handle Handle, buf []byte, done *uint32, overlapped *Overlapped) (err error) {
3053
	var _p0 *byte
3054
	if len(buf) > 0 {
3055
		_p0 = &buf[0]
3056
	}
3057
	r1, _, e1 := syscall.SyscallN(procReadFile.Addr(), uintptr(handle), uintptr(unsafe.Pointer(_p0)), uintptr(len(buf)), uintptr(unsafe.Pointer(done)), uintptr(unsafe.Pointer(overlapped)))
3058
	if r1 == 0 {
3059
		err = errnoErr(e1)
3060
	}
3061
	return
3062
}
3063

3064
func ReadProcessMemory(process Handle, baseAddress uintptr, buffer *byte, size uintptr, numberOfBytesRead *uintptr) (err error) {
3065
	r1, _, e1 := syscall.SyscallN(procReadProcessMemory.Addr(), uintptr(process), uintptr(baseAddress), uintptr(unsafe.Pointer(buffer)), uintptr(size), uintptr(unsafe.Pointer(numberOfBytesRead)))
3066
	if r1 == 0 {
3067
		err = errnoErr(e1)
3068
	}
3069
	return
3070
}
3071

3072
func ReleaseMutex(mutex Handle) (err error) {
3073
	r1, _, e1 := syscall.SyscallN(procReleaseMutex.Addr(), uintptr(mutex))
3074
	if r1 == 0 {
3075
		err = errnoErr(e1)
3076
	}
3077
	return
3078
}
3079

3080
func RemoveDirectory(path *uint16) (err error) {
3081
	r1, _, e1 := syscall.SyscallN(procRemoveDirectoryW.Addr(), uintptr(unsafe.Pointer(path)))
3082
	if r1 == 0 {
3083
		err = errnoErr(e1)
3084
	}
3085
	return
3086
}
3087

3088
func RemoveDllDirectory(cookie uintptr) (err error) {
3089
	r1, _, e1 := syscall.SyscallN(procRemoveDllDirectory.Addr(), uintptr(cookie))
3090
	if r1 == 0 {
3091
		err = errnoErr(e1)
3092
	}
3093
	return
3094
}
3095

3096
func ResetEvent(event Handle) (err error) {
3097
	r1, _, e1 := syscall.SyscallN(procResetEvent.Addr(), uintptr(event))
3098
	if r1 == 0 {
3099
		err = errnoErr(e1)
3100
	}
3101
	return
3102
}
3103

3104
func resizePseudoConsole(pconsole Handle, size uint32) (hr error) {
3105
	r0, _, _ := syscall.SyscallN(procResizePseudoConsole.Addr(), uintptr(pconsole), uintptr(size))
3106
	if r0 != 0 {
3107
		hr = syscall.Errno(r0)
3108
	}
3109
	return
3110
}
3111

3112
func ResumeThread(thread Handle) (ret uint32, err error) {
3113
	r0, _, e1 := syscall.SyscallN(procResumeThread.Addr(), uintptr(thread))
3114
	ret = uint32(r0)
3115
	if ret == 0xffffffff {
3116
		err = errnoErr(e1)
3117
	}
3118
	return
3119
}
3120

3121
func SetCommBreak(handle Handle) (err error) {
3122
	r1, _, e1 := syscall.SyscallN(procSetCommBreak.Addr(), uintptr(handle))
3123
	if r1 == 0 {
3124
		err = errnoErr(e1)
3125
	}
3126
	return
3127
}
3128

3129
func SetCommMask(handle Handle, dwEvtMask uint32) (err error) {
3130
	r1, _, e1 := syscall.SyscallN(procSetCommMask.Addr(), uintptr(handle), uintptr(dwEvtMask))
3131
	if r1 == 0 {
3132
		err = errnoErr(e1)
3133
	}
3134
	return
3135
}
3136

3137
func SetCommState(handle Handle, lpDCB *DCB) (err error) {
3138
	r1, _, e1 := syscall.SyscallN(procSetCommState.Addr(), uintptr(handle), uintptr(unsafe.Pointer(lpDCB)))
3139
	if r1 == 0 {
3140
		err = errnoErr(e1)
3141
	}
3142
	return
3143
}
3144

3145
func SetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error) {
3146
	r1, _, e1 := syscall.SyscallN(procSetCommTimeouts.Addr(), uintptr(handle), uintptr(unsafe.Pointer(timeouts)))
3147
	if r1 == 0 {
3148
		err = errnoErr(e1)
3149
	}
3150
	return
3151
}
3152

3153
func SetConsoleCP(cp uint32) (err error) {
3154
	r1, _, e1 := syscall.SyscallN(procSetConsoleCP.Addr(), uintptr(cp))
3155
	if r1 == 0 {
3156
		err = errnoErr(e1)
3157
	}
3158
	return
3159
}
3160

3161
func setConsoleCursorPosition(console Handle, position uint32) (err error) {
3162
	r1, _, e1 := syscall.SyscallN(procSetConsoleCursorPosition.Addr(), uintptr(console), uintptr(position))
3163
	if r1 == 0 {
3164
		err = errnoErr(e1)
3165
	}
3166
	return
3167
}
3168

3169
func SetConsoleMode(console Handle, mode uint32) (err error) {
3170
	r1, _, e1 := syscall.SyscallN(procSetConsoleMode.Addr(), uintptr(console), uintptr(mode))
3171
	if r1 == 0 {
3172
		err = errnoErr(e1)
3173
	}
3174
	return
3175
}
3176

3177
func SetConsoleOutputCP(cp uint32) (err error) {
3178
	r1, _, e1 := syscall.SyscallN(procSetConsoleOutputCP.Addr(), uintptr(cp))
3179
	if r1 == 0 {
3180
		err = errnoErr(e1)
3181
	}
3182
	return
3183
}
3184

3185
func SetCurrentDirectory(path *uint16) (err error) {
3186
	r1, _, e1 := syscall.SyscallN(procSetCurrentDirectoryW.Addr(), uintptr(unsafe.Pointer(path)))
3187
	if r1 == 0 {
3188
		err = errnoErr(e1)
3189
	}
3190
	return
3191
}
3192

3193
func SetDefaultDllDirectories(directoryFlags uint32) (err error) {
3194
	r1, _, e1 := syscall.SyscallN(procSetDefaultDllDirectories.Addr(), uintptr(directoryFlags))
3195
	if r1 == 0 {
3196
		err = errnoErr(e1)
3197
	}
3198
	return
3199
}
3200

3201
func SetDllDirectory(path string) (err error) {
3202
	var _p0 *uint16
3203
	_p0, err = syscall.UTF16PtrFromString(path)
3204
	if err != nil {
3205
		return
3206
	}
3207
	return _SetDllDirectory(_p0)
3208
}
3209

3210
func _SetDllDirectory(path *uint16) (err error) {
3211
	r1, _, e1 := syscall.SyscallN(procSetDllDirectoryW.Addr(), uintptr(unsafe.Pointer(path)))
3212
	if r1 == 0 {
3213
		err = errnoErr(e1)
3214
	}
3215
	return
3216
}
3217

3218
func SetEndOfFile(handle Handle) (err error) {
3219
	r1, _, e1 := syscall.SyscallN(procSetEndOfFile.Addr(), uintptr(handle))
3220
	if r1 == 0 {
3221
		err = errnoErr(e1)
3222
	}
3223
	return
3224
}
3225

3226
func SetEnvironmentVariable(name *uint16, value *uint16) (err error) {
3227
	r1, _, e1 := syscall.SyscallN(procSetEnvironmentVariableW.Addr(), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(value)))
3228
	if r1 == 0 {
3229
		err = errnoErr(e1)
3230
	}
3231
	return
3232
}
3233

3234
func SetErrorMode(mode uint32) (ret uint32) {
3235
	r0, _, _ := syscall.SyscallN(procSetErrorMode.Addr(), uintptr(mode))
3236
	ret = uint32(r0)
3237
	return
3238
}
3239

3240
func SetEvent(event Handle) (err error) {
3241
	r1, _, e1 := syscall.SyscallN(procSetEvent.Addr(), uintptr(event))
3242
	if r1 == 0 {
3243
		err = errnoErr(e1)
3244
	}
3245
	return
3246
}
3247

3248
func SetFileAttributes(name *uint16, attrs uint32) (err error) {
3249
	r1, _, e1 := syscall.SyscallN(procSetFileAttributesW.Addr(), uintptr(unsafe.Pointer(name)), uintptr(attrs))
3250
	if r1 == 0 {
3251
		err = errnoErr(e1)
3252
	}
3253
	return
3254
}
3255

3256
func SetFileCompletionNotificationModes(handle Handle, flags uint8) (err error) {
3257
	r1, _, e1 := syscall.SyscallN(procSetFileCompletionNotificationModes.Addr(), uintptr(handle), uintptr(flags))
3258
	if r1 == 0 {
3259
		err = errnoErr(e1)
3260
	}
3261
	return
3262
}
3263

3264
func SetFileInformationByHandle(handle Handle, class uint32, inBuffer *byte, inBufferLen uint32) (err error) {
3265
	r1, _, e1 := syscall.SyscallN(procSetFileInformationByHandle.Addr(), uintptr(handle), uintptr(class), uintptr(unsafe.Pointer(inBuffer)), uintptr(inBufferLen))
3266
	if r1 == 0 {
3267
		err = errnoErr(e1)
3268
	}
3269
	return
3270
}
3271

3272
func SetFilePointer(handle Handle, lowoffset int32, highoffsetptr *int32, whence uint32) (newlowoffset uint32, err error) {
3273
	r0, _, e1 := syscall.SyscallN(procSetFilePointer.Addr(), uintptr(handle), uintptr(lowoffset), uintptr(unsafe.Pointer(highoffsetptr)), uintptr(whence))
3274
	newlowoffset = uint32(r0)
3275
	if newlowoffset == 0xffffffff {
3276
		err = errnoErr(e1)
3277
	}
3278
	return
3279
}
3280

3281
func SetFileTime(handle Handle, ctime *Filetime, atime *Filetime, wtime *Filetime) (err error) {
3282
	r1, _, e1 := syscall.SyscallN(procSetFileTime.Addr(), uintptr(handle), uintptr(unsafe.Pointer(ctime)), uintptr(unsafe.Pointer(atime)), uintptr(unsafe.Pointer(wtime)))
3283
	if r1 == 0 {
3284
		err = errnoErr(e1)
3285
	}
3286
	return
3287
}
3288

3289
func SetFileValidData(handle Handle, validDataLength int64) (err error) {
3290
	r1, _, e1 := syscall.SyscallN(procSetFileValidData.Addr(), uintptr(handle), uintptr(validDataLength))
3291
	if r1 == 0 {
3292
		err = errnoErr(e1)
3293
	}
3294
	return
3295
}
3296

3297
func SetHandleInformation(handle Handle, mask uint32, flags uint32) (err error) {
3298
	r1, _, e1 := syscall.SyscallN(procSetHandleInformation.Addr(), uintptr(handle), uintptr(mask), uintptr(flags))
3299
	if r1 == 0 {
3300
		err = errnoErr(e1)
3301
	}
3302
	return
3303
}
3304

3305
func SetInformationJobObject(job Handle, JobObjectInformationClass uint32, JobObjectInformation uintptr, JobObjectInformationLength uint32) (ret int, err error) {
3306
	r0, _, e1 := syscall.SyscallN(procSetInformationJobObject.Addr(), uintptr(job), uintptr(JobObjectInformationClass), uintptr(JobObjectInformation), uintptr(JobObjectInformationLength))
3307
	ret = int(r0)
3308
	if ret == 0 {
3309
		err = errnoErr(e1)
3310
	}
3311
	return
3312
}
3313

3314
func SetNamedPipeHandleState(pipe Handle, state *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32) (err error) {
3315
	r1, _, e1 := syscall.SyscallN(procSetNamedPipeHandleState.Addr(), uintptr(pipe), uintptr(unsafe.Pointer(state)), uintptr(unsafe.Pointer(maxCollectionCount)), uintptr(unsafe.Pointer(collectDataTimeout)))
3316
	if r1 == 0 {
3317
		err = errnoErr(e1)
3318
	}
3319
	return
3320
}
3321

3322
func SetPriorityClass(process Handle, priorityClass uint32) (err error) {
3323
	r1, _, e1 := syscall.SyscallN(procSetPriorityClass.Addr(), uintptr(process), uintptr(priorityClass))
3324
	if r1 == 0 {
3325
		err = errnoErr(e1)
3326
	}
3327
	return
3328
}
3329

3330
func SetProcessPriorityBoost(process Handle, disable bool) (err error) {
3331
	var _p0 uint32
3332
	if disable {
3333
		_p0 = 1
3334
	}
3335
	r1, _, e1 := syscall.SyscallN(procSetProcessPriorityBoost.Addr(), uintptr(process), uintptr(_p0))
3336
	if r1 == 0 {
3337
		err = errnoErr(e1)
3338
	}
3339
	return
3340
}
3341

3342
func SetProcessShutdownParameters(level uint32, flags uint32) (err error) {
3343
	r1, _, e1 := syscall.SyscallN(procSetProcessShutdownParameters.Addr(), uintptr(level), uintptr(flags))
3344
	if r1 == 0 {
3345
		err = errnoErr(e1)
3346
	}
3347
	return
3348
}
3349

3350
func SetProcessWorkingSetSizeEx(hProcess Handle, dwMinimumWorkingSetSize uintptr, dwMaximumWorkingSetSize uintptr, flags uint32) (err error) {
3351
	r1, _, e1 := syscall.SyscallN(procSetProcessWorkingSetSizeEx.Addr(), uintptr(hProcess), uintptr(dwMinimumWorkingSetSize), uintptr(dwMaximumWorkingSetSize), uintptr(flags))
3352
	if r1 == 0 {
3353
		err = errnoErr(e1)
3354
	}
3355
	return
3356
}
3357

3358
func SetStdHandle(stdhandle uint32, handle Handle) (err error) {
3359
	r1, _, e1 := syscall.SyscallN(procSetStdHandle.Addr(), uintptr(stdhandle), uintptr(handle))
3360
	if r1 == 0 {
3361
		err = errnoErr(e1)
3362
	}
3363
	return
3364
}
3365

3366
func SetVolumeLabel(rootPathName *uint16, volumeName *uint16) (err error) {
3367
	r1, _, e1 := syscall.SyscallN(procSetVolumeLabelW.Addr(), uintptr(unsafe.Pointer(rootPathName)), uintptr(unsafe.Pointer(volumeName)))
3368
	if r1 == 0 {
3369
		err = errnoErr(e1)
3370
	}
3371
	return
3372
}
3373

3374
func SetVolumeMountPoint(volumeMountPoint *uint16, volumeName *uint16) (err error) {
3375
	r1, _, e1 := syscall.SyscallN(procSetVolumeMountPointW.Addr(), uintptr(unsafe.Pointer(volumeMountPoint)), uintptr(unsafe.Pointer(volumeName)))
3376
	if r1 == 0 {
3377
		err = errnoErr(e1)
3378
	}
3379
	return
3380
}
3381

3382
func SetupComm(handle Handle, dwInQueue uint32, dwOutQueue uint32) (err error) {
3383
	r1, _, e1 := syscall.SyscallN(procSetupComm.Addr(), uintptr(handle), uintptr(dwInQueue), uintptr(dwOutQueue))
3384
	if r1 == 0 {
3385
		err = errnoErr(e1)
3386
	}
3387
	return
3388
}
3389

3390
func SizeofResource(module Handle, resInfo Handle) (size uint32, err error) {
3391
	r0, _, e1 := syscall.SyscallN(procSizeofResource.Addr(), uintptr(module), uintptr(resInfo))
3392
	size = uint32(r0)
3393
	if size == 0 {
3394
		err = errnoErr(e1)
3395
	}
3396
	return
3397
}
3398

3399
func SleepEx(milliseconds uint32, alertable bool) (ret uint32) {
3400
	var _p0 uint32
3401
	if alertable {
3402
		_p0 = 1
3403
	}
3404
	r0, _, _ := syscall.SyscallN(procSleepEx.Addr(), uintptr(milliseconds), uintptr(_p0))
3405
	ret = uint32(r0)
3406
	return
3407
}
3408

3409
func TerminateJobObject(job Handle, exitCode uint32) (err error) {
3410
	r1, _, e1 := syscall.SyscallN(procTerminateJobObject.Addr(), uintptr(job), uintptr(exitCode))
3411
	if r1 == 0 {
3412
		err = errnoErr(e1)
3413
	}
3414
	return
3415
}
3416

3417
func TerminateProcess(handle Handle, exitcode uint32) (err error) {
3418
	r1, _, e1 := syscall.SyscallN(procTerminateProcess.Addr(), uintptr(handle), uintptr(exitcode))
3419
	if r1 == 0 {
3420
		err = errnoErr(e1)
3421
	}
3422
	return
3423
}
3424

3425
func Thread32First(snapshot Handle, threadEntry *ThreadEntry32) (err error) {
3426
	r1, _, e1 := syscall.SyscallN(procThread32First.Addr(), uintptr(snapshot), uintptr(unsafe.Pointer(threadEntry)))
3427
	if r1 == 0 {
3428
		err = errnoErr(e1)
3429
	}
3430
	return
3431
}
3432

3433
func Thread32Next(snapshot Handle, threadEntry *ThreadEntry32) (err error) {
3434
	r1, _, e1 := syscall.SyscallN(procThread32Next.Addr(), uintptr(snapshot), uintptr(unsafe.Pointer(threadEntry)))
3435
	if r1 == 0 {
3436
		err = errnoErr(e1)
3437
	}
3438
	return
3439
}
3440

3441
func UnlockFileEx(file Handle, reserved uint32, bytesLow uint32, bytesHigh uint32, overlapped *Overlapped) (err error) {
3442
	r1, _, e1 := syscall.SyscallN(procUnlockFileEx.Addr(), uintptr(file), uintptr(reserved), uintptr(bytesLow), uintptr(bytesHigh), uintptr(unsafe.Pointer(overlapped)))
3443
	if r1 == 0 {
3444
		err = errnoErr(e1)
3445
	}
3446
	return
3447
}
3448

3449
func UnmapViewOfFile(addr uintptr) (err error) {
3450
	r1, _, e1 := syscall.SyscallN(procUnmapViewOfFile.Addr(), uintptr(addr))
3451
	if r1 == 0 {
3452
		err = errnoErr(e1)
3453
	}
3454
	return
3455
}
3456

3457
func updateProcThreadAttribute(attrlist *ProcThreadAttributeList, flags uint32, attr uintptr, value unsafe.Pointer, size uintptr, prevvalue unsafe.Pointer, returnedsize *uintptr) (err error) {
3458
	r1, _, e1 := syscall.SyscallN(procUpdateProcThreadAttribute.Addr(), uintptr(unsafe.Pointer(attrlist)), uintptr(flags), uintptr(attr), uintptr(value), uintptr(size), uintptr(prevvalue), uintptr(unsafe.Pointer(returnedsize)))
3459
	if r1 == 0 {
3460
		err = errnoErr(e1)
3461
	}
3462
	return
3463
}
3464

3465
func VirtualAlloc(address uintptr, size uintptr, alloctype uint32, protect uint32) (value uintptr, err error) {
3466
	r0, _, e1 := syscall.SyscallN(procVirtualAlloc.Addr(), uintptr(address), uintptr(size), uintptr(alloctype), uintptr(protect))
3467
	value = uintptr(r0)
3468
	if value == 0 {
3469
		err = errnoErr(e1)
3470
	}
3471
	return
3472
}
3473

3474
func VirtualFree(address uintptr, size uintptr, freetype uint32) (err error) {
3475
	r1, _, e1 := syscall.SyscallN(procVirtualFree.Addr(), uintptr(address), uintptr(size), uintptr(freetype))
3476
	if r1 == 0 {
3477
		err = errnoErr(e1)
3478
	}
3479
	return
3480
}
3481

3482
func VirtualLock(addr uintptr, length uintptr) (err error) {
3483
	r1, _, e1 := syscall.SyscallN(procVirtualLock.Addr(), uintptr(addr), uintptr(length))
3484
	if r1 == 0 {
3485
		err = errnoErr(e1)
3486
	}
3487
	return
3488
}
3489

3490
func VirtualProtect(address uintptr, size uintptr, newprotect uint32, oldprotect *uint32) (err error) {
3491
	r1, _, e1 := syscall.SyscallN(procVirtualProtect.Addr(), uintptr(address), uintptr(size), uintptr(newprotect), uintptr(unsafe.Pointer(oldprotect)))
3492
	if r1 == 0 {
3493
		err = errnoErr(e1)
3494
	}
3495
	return
3496
}
3497

3498
func VirtualProtectEx(process Handle, address uintptr, size uintptr, newProtect uint32, oldProtect *uint32) (err error) {
3499
	r1, _, e1 := syscall.SyscallN(procVirtualProtectEx.Addr(), uintptr(process), uintptr(address), uintptr(size), uintptr(newProtect), uintptr(unsafe.Pointer(oldProtect)))
3500
	if r1 == 0 {
3501
		err = errnoErr(e1)
3502
	}
3503
	return
3504
}
3505

3506
func VirtualQuery(address uintptr, buffer *MemoryBasicInformation, length uintptr) (err error) {
3507
	r1, _, e1 := syscall.SyscallN(procVirtualQuery.Addr(), uintptr(address), uintptr(unsafe.Pointer(buffer)), uintptr(length))
3508
	if r1 == 0 {
3509
		err = errnoErr(e1)
3510
	}
3511
	return
3512
}
3513

3514
func VirtualQueryEx(process Handle, address uintptr, buffer *MemoryBasicInformation, length uintptr) (err error) {
3515
	r1, _, e1 := syscall.SyscallN(procVirtualQueryEx.Addr(), uintptr(process), uintptr(address), uintptr(unsafe.Pointer(buffer)), uintptr(length))
3516
	if r1 == 0 {
3517
		err = errnoErr(e1)
3518
	}
3519
	return
3520
}
3521

3522
func VirtualUnlock(addr uintptr, length uintptr) (err error) {
3523
	r1, _, e1 := syscall.SyscallN(procVirtualUnlock.Addr(), uintptr(addr), uintptr(length))
3524
	if r1 == 0 {
3525
		err = errnoErr(e1)
3526
	}
3527
	return
3528
}
3529

3530
func WTSGetActiveConsoleSessionId() (sessionID uint32) {
3531
	r0, _, _ := syscall.SyscallN(procWTSGetActiveConsoleSessionId.Addr())
3532
	sessionID = uint32(r0)
3533
	return
3534
}
3535

3536
func WaitCommEvent(handle Handle, lpEvtMask *uint32, lpOverlapped *Overlapped) (err error) {
3537
	r1, _, e1 := syscall.SyscallN(procWaitCommEvent.Addr(), uintptr(handle), uintptr(unsafe.Pointer(lpEvtMask)), uintptr(unsafe.Pointer(lpOverlapped)))
3538
	if r1 == 0 {
3539
		err = errnoErr(e1)
3540
	}
3541
	return
3542
}
3543

3544
func waitForMultipleObjects(count uint32, handles uintptr, waitAll bool, waitMilliseconds uint32) (event uint32, err error) {
3545
	var _p0 uint32
3546
	if waitAll {
3547
		_p0 = 1
3548
	}
3549
	r0, _, e1 := syscall.SyscallN(procWaitForMultipleObjects.Addr(), uintptr(count), uintptr(handles), uintptr(_p0), uintptr(waitMilliseconds))
3550
	event = uint32(r0)
3551
	if event == 0xffffffff {
3552
		err = errnoErr(e1)
3553
	}
3554
	return
3555
}
3556

3557
func WaitForSingleObject(handle Handle, waitMilliseconds uint32) (event uint32, err error) {
3558
	r0, _, e1 := syscall.SyscallN(procWaitForSingleObject.Addr(), uintptr(handle), uintptr(waitMilliseconds))
3559
	event = uint32(r0)
3560
	if event == 0xffffffff {
3561
		err = errnoErr(e1)
3562
	}
3563
	return
3564
}
3565

3566
func WriteConsole(console Handle, buf *uint16, towrite uint32, written *uint32, reserved *byte) (err error) {
3567
	r1, _, e1 := syscall.SyscallN(procWriteConsoleW.Addr(), uintptr(console), uintptr(unsafe.Pointer(buf)), uintptr(towrite), uintptr(unsafe.Pointer(written)), uintptr(unsafe.Pointer(reserved)))
3568
	if r1 == 0 {
3569
		err = errnoErr(e1)
3570
	}
3571
	return
3572
}
3573

3574
func writeFile(handle Handle, buf []byte, done *uint32, overlapped *Overlapped) (err error) {
3575
	var _p0 *byte
3576
	if len(buf) > 0 {
3577
		_p0 = &buf[0]
3578
	}
3579
	r1, _, e1 := syscall.SyscallN(procWriteFile.Addr(), uintptr(handle), uintptr(unsafe.Pointer(_p0)), uintptr(len(buf)), uintptr(unsafe.Pointer(done)), uintptr(unsafe.Pointer(overlapped)))
3580
	if r1 == 0 {
3581
		err = errnoErr(e1)
3582
	}
3583
	return
3584
}
3585

3586
func WriteProcessMemory(process Handle, baseAddress uintptr, buffer *byte, size uintptr, numberOfBytesWritten *uintptr) (err error) {
3587
	r1, _, e1 := syscall.SyscallN(procWriteProcessMemory.Addr(), uintptr(process), uintptr(baseAddress), uintptr(unsafe.Pointer(buffer)), uintptr(size), uintptr(unsafe.Pointer(numberOfBytesWritten)))
3588
	if r1 == 0 {
3589
		err = errnoErr(e1)
3590
	}
3591
	return
3592
}
3593

3594
func AcceptEx(ls Handle, as Handle, buf *byte, rxdatalen uint32, laddrlen uint32, raddrlen uint32, recvd *uint32, overlapped *Overlapped) (err error) {
3595
	r1, _, e1 := syscall.SyscallN(procAcceptEx.Addr(), uintptr(ls), uintptr(as), uintptr(unsafe.Pointer(buf)), uintptr(rxdatalen), uintptr(laddrlen), uintptr(raddrlen), uintptr(unsafe.Pointer(recvd)), uintptr(unsafe.Pointer(overlapped)))
3596
	if r1 == 0 {
3597
		err = errnoErr(e1)
3598
	}
3599
	return
3600
}
3601

3602
func GetAcceptExSockaddrs(buf *byte, rxdatalen uint32, laddrlen uint32, raddrlen uint32, lrsa **RawSockaddrAny, lrsalen *int32, rrsa **RawSockaddrAny, rrsalen *int32) {
3603
	syscall.SyscallN(procGetAcceptExSockaddrs.Addr(), uintptr(unsafe.Pointer(buf)), uintptr(rxdatalen), uintptr(laddrlen), uintptr(raddrlen), uintptr(unsafe.Pointer(lrsa)), uintptr(unsafe.Pointer(lrsalen)), uintptr(unsafe.Pointer(rrsa)), uintptr(unsafe.Pointer(rrsalen)))
3604
	return
3605
}
3606

3607
func TransmitFile(s Handle, handle Handle, bytesToWrite uint32, bytsPerSend uint32, overlapped *Overlapped, transmitFileBuf *TransmitFileBuffers, flags uint32) (err error) {
3608
	r1, _, e1 := syscall.SyscallN(procTransmitFile.Addr(), uintptr(s), uintptr(handle), uintptr(bytesToWrite), uintptr(bytsPerSend), uintptr(unsafe.Pointer(overlapped)), uintptr(unsafe.Pointer(transmitFileBuf)), uintptr(flags))
3609
	if r1 == 0 {
3610
		err = errnoErr(e1)
3611
	}
3612
	return
3613
}
3614

3615
func NetApiBufferFree(buf *byte) (neterr error) {
3616
	r0, _, _ := syscall.SyscallN(procNetApiBufferFree.Addr(), uintptr(unsafe.Pointer(buf)))
3617
	if r0 != 0 {
3618
		neterr = syscall.Errno(r0)
3619
	}
3620
	return
3621
}
3622

3623
func NetGetJoinInformation(server *uint16, name **uint16, bufType *uint32) (neterr error) {
3624
	r0, _, _ := syscall.SyscallN(procNetGetJoinInformation.Addr(), uintptr(unsafe.Pointer(server)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(bufType)))
3625
	if r0 != 0 {
3626
		neterr = syscall.Errno(r0)
3627
	}
3628
	return
3629
}
3630

3631
func NetUserEnum(serverName *uint16, level uint32, filter uint32, buf **byte, prefMaxLen uint32, entriesRead *uint32, totalEntries *uint32, resumeHandle *uint32) (neterr error) {
3632
	r0, _, _ := syscall.SyscallN(procNetUserEnum.Addr(), uintptr(unsafe.Pointer(serverName)), uintptr(level), uintptr(filter), uintptr(unsafe.Pointer(buf)), uintptr(prefMaxLen), uintptr(unsafe.Pointer(entriesRead)), uintptr(unsafe.Pointer(totalEntries)), uintptr(unsafe.Pointer(resumeHandle)))
3633
	if r0 != 0 {
3634
		neterr = syscall.Errno(r0)
3635
	}
3636
	return
3637
}
3638

3639
func NetUserGetInfo(serverName *uint16, userName *uint16, level uint32, buf **byte) (neterr error) {
3640
	r0, _, _ := syscall.SyscallN(procNetUserGetInfo.Addr(), uintptr(unsafe.Pointer(serverName)), uintptr(unsafe.Pointer(userName)), uintptr(level), uintptr(unsafe.Pointer(buf)))
3641
	if r0 != 0 {
3642
		neterr = syscall.Errno(r0)
3643
	}
3644
	return
3645
}
3646

3647
func NtCreateFile(handle *Handle, access uint32, oa *OBJECT_ATTRIBUTES, iosb *IO_STATUS_BLOCK, allocationSize *int64, attributes uint32, share uint32, disposition uint32, options uint32, eabuffer uintptr, ealength uint32) (ntstatus error) {
3648
	r0, _, _ := syscall.SyscallN(procNtCreateFile.Addr(), uintptr(unsafe.Pointer(handle)), uintptr(access), uintptr(unsafe.Pointer(oa)), uintptr(unsafe.Pointer(iosb)), uintptr(unsafe.Pointer(allocationSize)), uintptr(attributes), uintptr(share), uintptr(disposition), uintptr(options), uintptr(eabuffer), uintptr(ealength))
3649
	if r0 != 0 {
3650
		ntstatus = NTStatus(r0)
3651
	}
3652
	return
3653
}
3654

3655
func NtCreateNamedPipeFile(pipe *Handle, access uint32, oa *OBJECT_ATTRIBUTES, iosb *IO_STATUS_BLOCK, share uint32, disposition uint32, options uint32, typ uint32, readMode uint32, completionMode uint32, maxInstances uint32, inboundQuota uint32, outputQuota uint32, timeout *int64) (ntstatus error) {
3656
	r0, _, _ := syscall.SyscallN(procNtCreateNamedPipeFile.Addr(), uintptr(unsafe.Pointer(pipe)), uintptr(access), uintptr(unsafe.Pointer(oa)), uintptr(unsafe.Pointer(iosb)), uintptr(share), uintptr(disposition), uintptr(options), uintptr(typ), uintptr(readMode), uintptr(completionMode), uintptr(maxInstances), uintptr(inboundQuota), uintptr(outputQuota), uintptr(unsafe.Pointer(timeout)))
3657
	if r0 != 0 {
3658
		ntstatus = NTStatus(r0)
3659
	}
3660
	return
3661
}
3662

3663
func NtQueryInformationProcess(proc Handle, procInfoClass int32, procInfo unsafe.Pointer, procInfoLen uint32, retLen *uint32) (ntstatus error) {
3664
	r0, _, _ := syscall.SyscallN(procNtQueryInformationProcess.Addr(), uintptr(proc), uintptr(procInfoClass), uintptr(procInfo), uintptr(procInfoLen), uintptr(unsafe.Pointer(retLen)))
3665
	if r0 != 0 {
3666
		ntstatus = NTStatus(r0)
3667
	}
3668
	return
3669
}
3670

3671
func NtQuerySystemInformation(sysInfoClass int32, sysInfo unsafe.Pointer, sysInfoLen uint32, retLen *uint32) (ntstatus error) {
3672
	r0, _, _ := syscall.SyscallN(procNtQuerySystemInformation.Addr(), uintptr(sysInfoClass), uintptr(sysInfo), uintptr(sysInfoLen), uintptr(unsafe.Pointer(retLen)))
3673
	if r0 != 0 {
3674
		ntstatus = NTStatus(r0)
3675
	}
3676
	return
3677
}
3678

3679
func NtSetInformationFile(handle Handle, iosb *IO_STATUS_BLOCK, inBuffer *byte, inBufferLen uint32, class uint32) (ntstatus error) {
3680
	r0, _, _ := syscall.SyscallN(procNtSetInformationFile.Addr(), uintptr(handle), uintptr(unsafe.Pointer(iosb)), uintptr(unsafe.Pointer(inBuffer)), uintptr(inBufferLen), uintptr(class))
3681
	if r0 != 0 {
3682
		ntstatus = NTStatus(r0)
3683
	}
3684
	return
3685
}
3686

3687
func NtSetInformationProcess(proc Handle, procInfoClass int32, procInfo unsafe.Pointer, procInfoLen uint32) (ntstatus error) {
3688
	r0, _, _ := syscall.SyscallN(procNtSetInformationProcess.Addr(), uintptr(proc), uintptr(procInfoClass), uintptr(procInfo), uintptr(procInfoLen))
3689
	if r0 != 0 {
3690
		ntstatus = NTStatus(r0)
3691
	}
3692
	return
3693
}
3694

3695
func NtSetSystemInformation(sysInfoClass int32, sysInfo unsafe.Pointer, sysInfoLen uint32) (ntstatus error) {
3696
	r0, _, _ := syscall.SyscallN(procNtSetSystemInformation.Addr(), uintptr(sysInfoClass), uintptr(sysInfo), uintptr(sysInfoLen))
3697
	if r0 != 0 {
3698
		ntstatus = NTStatus(r0)
3699
	}
3700
	return
3701
}
3702

3703
func RtlAddFunctionTable(functionTable *RUNTIME_FUNCTION, entryCount uint32, baseAddress uintptr) (ret bool) {
3704
	r0, _, _ := syscall.SyscallN(procRtlAddFunctionTable.Addr(), uintptr(unsafe.Pointer(functionTable)), uintptr(entryCount), uintptr(baseAddress))
3705
	ret = r0 != 0
3706
	return
3707
}
3708

3709
func RtlDefaultNpAcl(acl **ACL) (ntstatus error) {
3710
	r0, _, _ := syscall.SyscallN(procRtlDefaultNpAcl.Addr(), uintptr(unsafe.Pointer(acl)))
3711
	if r0 != 0 {
3712
		ntstatus = NTStatus(r0)
3713
	}
3714
	return
3715
}
3716

3717
func RtlDeleteFunctionTable(functionTable *RUNTIME_FUNCTION) (ret bool) {
3718
	r0, _, _ := syscall.SyscallN(procRtlDeleteFunctionTable.Addr(), uintptr(unsafe.Pointer(functionTable)))
3719
	ret = r0 != 0
3720
	return
3721
}
3722

3723
func RtlDosPathNameToNtPathName(dosName *uint16, ntName *NTUnicodeString, ntFileNamePart *uint16, relativeName *RTL_RELATIVE_NAME) (ntstatus error) {
3724
	r0, _, _ := syscall.SyscallN(procRtlDosPathNameToNtPathName_U_WithStatus.Addr(), uintptr(unsafe.Pointer(dosName)), uintptr(unsafe.Pointer(ntName)), uintptr(unsafe.Pointer(ntFileNamePart)), uintptr(unsafe.Pointer(relativeName)))
3725
	if r0 != 0 {
3726
		ntstatus = NTStatus(r0)
3727
	}
3728
	return
3729
}
3730

3731
func RtlDosPathNameToRelativeNtPathName(dosName *uint16, ntName *NTUnicodeString, ntFileNamePart *uint16, relativeName *RTL_RELATIVE_NAME) (ntstatus error) {
3732
	r0, _, _ := syscall.SyscallN(procRtlDosPathNameToRelativeNtPathName_U_WithStatus.Addr(), uintptr(unsafe.Pointer(dosName)), uintptr(unsafe.Pointer(ntName)), uintptr(unsafe.Pointer(ntFileNamePart)), uintptr(unsafe.Pointer(relativeName)))
3733
	if r0 != 0 {
3734
		ntstatus = NTStatus(r0)
3735
	}
3736
	return
3737
}
3738

3739
func RtlGetCurrentPeb() (peb *PEB) {
3740
	r0, _, _ := syscall.SyscallN(procRtlGetCurrentPeb.Addr())
3741
	peb = (*PEB)(unsafe.Pointer(r0))
3742
	return
3743
}
3744

3745
func rtlGetNtVersionNumbers(majorVersion *uint32, minorVersion *uint32, buildNumber *uint32) {
3746
	syscall.SyscallN(procRtlGetNtVersionNumbers.Addr(), uintptr(unsafe.Pointer(majorVersion)), uintptr(unsafe.Pointer(minorVersion)), uintptr(unsafe.Pointer(buildNumber)))
3747
	return
3748
}
3749

3750
func rtlGetVersion(info *OsVersionInfoEx) (ntstatus error) {
3751
	r0, _, _ := syscall.SyscallN(procRtlGetVersion.Addr(), uintptr(unsafe.Pointer(info)))
3752
	if r0 != 0 {
3753
		ntstatus = NTStatus(r0)
3754
	}
3755
	return
3756
}
3757

3758
func RtlInitString(destinationString *NTString, sourceString *byte) {
3759
	syscall.SyscallN(procRtlInitString.Addr(), uintptr(unsafe.Pointer(destinationString)), uintptr(unsafe.Pointer(sourceString)))
3760
	return
3761
}
3762

3763
func RtlInitUnicodeString(destinationString *NTUnicodeString, sourceString *uint16) {
3764
	syscall.SyscallN(procRtlInitUnicodeString.Addr(), uintptr(unsafe.Pointer(destinationString)), uintptr(unsafe.Pointer(sourceString)))
3765
	return
3766
}
3767

3768
func rtlNtStatusToDosErrorNoTeb(ntstatus NTStatus) (ret syscall.Errno) {
3769
	r0, _, _ := syscall.SyscallN(procRtlNtStatusToDosErrorNoTeb.Addr(), uintptr(ntstatus))
3770
	ret = syscall.Errno(r0)
3771
	return
3772
}
3773

3774
func clsidFromString(lpsz *uint16, pclsid *GUID) (ret error) {
3775
	r0, _, _ := syscall.SyscallN(procCLSIDFromString.Addr(), uintptr(unsafe.Pointer(lpsz)), uintptr(unsafe.Pointer(pclsid)))
3776
	if r0 != 0 {
3777
		ret = syscall.Errno(r0)
3778
	}
3779
	return
3780
}
3781

3782
func coCreateGuid(pguid *GUID) (ret error) {
3783
	r0, _, _ := syscall.SyscallN(procCoCreateGuid.Addr(), uintptr(unsafe.Pointer(pguid)))
3784
	if r0 != 0 {
3785
		ret = syscall.Errno(r0)
3786
	}
3787
	return
3788
}
3789

3790
func CoGetObject(name *uint16, bindOpts *BIND_OPTS3, guid *GUID, functionTable **uintptr) (ret error) {
3791
	r0, _, _ := syscall.SyscallN(procCoGetObject.Addr(), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(bindOpts)), uintptr(unsafe.Pointer(guid)), uintptr(unsafe.Pointer(functionTable)))
3792
	if r0 != 0 {
3793
		ret = syscall.Errno(r0)
3794
	}
3795
	return
3796
}
3797

3798
func CoInitializeEx(reserved uintptr, coInit uint32) (ret error) {
3799
	r0, _, _ := syscall.SyscallN(procCoInitializeEx.Addr(), uintptr(reserved), uintptr(coInit))
3800
	if r0 != 0 {
3801
		ret = syscall.Errno(r0)
3802
	}
3803
	return
3804
}
3805

3806
func CoTaskMemFree(address unsafe.Pointer) {
3807
	syscall.SyscallN(procCoTaskMemFree.Addr(), uintptr(address))
3808
	return
3809
}
3810

3811
func CoUninitialize() {
3812
	syscall.SyscallN(procCoUninitialize.Addr())
3813
	return
3814
}
3815

3816
func stringFromGUID2(rguid *GUID, lpsz *uint16, cchMax int32) (chars int32) {
3817
	r0, _, _ := syscall.SyscallN(procStringFromGUID2.Addr(), uintptr(unsafe.Pointer(rguid)), uintptr(unsafe.Pointer(lpsz)), uintptr(cchMax))
3818
	chars = int32(r0)
3819
	return
3820
}
3821

3822
func EnumProcessModules(process Handle, module *Handle, cb uint32, cbNeeded *uint32) (err error) {
3823
	r1, _, e1 := syscall.SyscallN(procEnumProcessModules.Addr(), uintptr(process), uintptr(unsafe.Pointer(module)), uintptr(cb), uintptr(unsafe.Pointer(cbNeeded)))
3824
	if r1 == 0 {
3825
		err = errnoErr(e1)
3826
	}
3827
	return
3828
}
3829

3830
func EnumProcessModulesEx(process Handle, module *Handle, cb uint32, cbNeeded *uint32, filterFlag uint32) (err error) {
3831
	r1, _, e1 := syscall.SyscallN(procEnumProcessModulesEx.Addr(), uintptr(process), uintptr(unsafe.Pointer(module)), uintptr(cb), uintptr(unsafe.Pointer(cbNeeded)), uintptr(filterFlag))
3832
	if r1 == 0 {
3833
		err = errnoErr(e1)
3834
	}
3835
	return
3836
}
3837

3838
func enumProcesses(processIds *uint32, nSize uint32, bytesReturned *uint32) (err error) {
3839
	r1, _, e1 := syscall.SyscallN(procEnumProcesses.Addr(), uintptr(unsafe.Pointer(processIds)), uintptr(nSize), uintptr(unsafe.Pointer(bytesReturned)))
3840
	if r1 == 0 {
3841
		err = errnoErr(e1)
3842
	}
3843
	return
3844
}
3845

3846
func GetModuleBaseName(process Handle, module Handle, baseName *uint16, size uint32) (err error) {
3847
	r1, _, e1 := syscall.SyscallN(procGetModuleBaseNameW.Addr(), uintptr(process), uintptr(module), uintptr(unsafe.Pointer(baseName)), uintptr(size))
3848
	if r1 == 0 {
3849
		err = errnoErr(e1)
3850
	}
3851
	return
3852
}
3853

3854
func GetModuleFileNameEx(process Handle, module Handle, filename *uint16, size uint32) (err error) {
3855
	r1, _, e1 := syscall.SyscallN(procGetModuleFileNameExW.Addr(), uintptr(process), uintptr(module), uintptr(unsafe.Pointer(filename)), uintptr(size))
3856
	if r1 == 0 {
3857
		err = errnoErr(e1)
3858
	}
3859
	return
3860
}
3861

3862
func GetModuleInformation(process Handle, module Handle, modinfo *ModuleInfo, cb uint32) (err error) {
3863
	r1, _, e1 := syscall.SyscallN(procGetModuleInformation.Addr(), uintptr(process), uintptr(module), uintptr(unsafe.Pointer(modinfo)), uintptr(cb))
3864
	if r1 == 0 {
3865
		err = errnoErr(e1)
3866
	}
3867
	return
3868
}
3869

3870
func QueryWorkingSetEx(process Handle, pv uintptr, cb uint32) (err error) {
3871
	r1, _, e1 := syscall.SyscallN(procQueryWorkingSetEx.Addr(), uintptr(process), uintptr(pv), uintptr(cb))
3872
	if r1 == 0 {
3873
		err = errnoErr(e1)
3874
	}
3875
	return
3876
}
3877

3878
func SubscribeServiceChangeNotifications(service Handle, eventType uint32, callback uintptr, callbackCtx uintptr, subscription *uintptr) (ret error) {
3879
	ret = procSubscribeServiceChangeNotifications.Find()
3880
	if ret != nil {
3881
		return
3882
	}
3883
	r0, _, _ := syscall.SyscallN(procSubscribeServiceChangeNotifications.Addr(), uintptr(service), uintptr(eventType), uintptr(callback), uintptr(callbackCtx), uintptr(unsafe.Pointer(subscription)))
3884
	if r0 != 0 {
3885
		ret = syscall.Errno(r0)
3886
	}
3887
	return
3888
}
3889

3890
func UnsubscribeServiceChangeNotifications(subscription uintptr) (err error) {
3891
	err = procUnsubscribeServiceChangeNotifications.Find()
3892
	if err != nil {
3893
		return
3894
	}
3895
	syscall.SyscallN(procUnsubscribeServiceChangeNotifications.Addr(), uintptr(subscription))
3896
	return
3897
}
3898

3899
func GetUserNameEx(nameFormat uint32, nameBuffre *uint16, nSize *uint32) (err error) {
3900
	r1, _, e1 := syscall.SyscallN(procGetUserNameExW.Addr(), uintptr(nameFormat), uintptr(unsafe.Pointer(nameBuffre)), uintptr(unsafe.Pointer(nSize)))
3901
	if r1&0xff == 0 {
3902
		err = errnoErr(e1)
3903
	}
3904
	return
3905
}
3906

3907
func TranslateName(accName *uint16, accNameFormat uint32, desiredNameFormat uint32, translatedName *uint16, nSize *uint32) (err error) {
3908
	r1, _, e1 := syscall.SyscallN(procTranslateNameW.Addr(), uintptr(unsafe.Pointer(accName)), uintptr(accNameFormat), uintptr(desiredNameFormat), uintptr(unsafe.Pointer(translatedName)), uintptr(unsafe.Pointer(nSize)))
3909
	if r1&0xff == 0 {
3910
		err = errnoErr(e1)
3911
	}
3912
	return
3913
}
3914

3915
func SetupDiBuildDriverInfoList(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverType SPDIT) (err error) {
3916
	r1, _, e1 := syscall.SyscallN(procSetupDiBuildDriverInfoList.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(driverType))
3917
	if r1 == 0 {
3918
		err = errnoErr(e1)
3919
	}
3920
	return
3921
}
3922

3923
func SetupDiCallClassInstaller(installFunction DI_FUNCTION, deviceInfoSet DevInfo, deviceInfoData *DevInfoData) (err error) {
3924
	r1, _, e1 := syscall.SyscallN(procSetupDiCallClassInstaller.Addr(), uintptr(installFunction), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)))
3925
	if r1 == 0 {
3926
		err = errnoErr(e1)
3927
	}
3928
	return
3929
}
3930

3931
func SetupDiCancelDriverInfoSearch(deviceInfoSet DevInfo) (err error) {
3932
	r1, _, e1 := syscall.SyscallN(procSetupDiCancelDriverInfoSearch.Addr(), uintptr(deviceInfoSet))
3933
	if r1 == 0 {
3934
		err = errnoErr(e1)
3935
	}
3936
	return
3937
}
3938

3939
func setupDiClassGuidsFromNameEx(className *uint16, classGuidList *GUID, classGuidListSize uint32, requiredSize *uint32, machineName *uint16, reserved uintptr) (err error) {
3940
	r1, _, e1 := syscall.SyscallN(procSetupDiClassGuidsFromNameExW.Addr(), uintptr(unsafe.Pointer(className)), uintptr(unsafe.Pointer(classGuidList)), uintptr(classGuidListSize), uintptr(unsafe.Pointer(requiredSize)), uintptr(unsafe.Pointer(machineName)), uintptr(reserved))
3941
	if r1 == 0 {
3942
		err = errnoErr(e1)
3943
	}
3944
	return
3945
}
3946

3947
func setupDiClassNameFromGuidEx(classGUID *GUID, className *uint16, classNameSize uint32, requiredSize *uint32, machineName *uint16, reserved uintptr) (err error) {
3948
	r1, _, e1 := syscall.SyscallN(procSetupDiClassNameFromGuidExW.Addr(), uintptr(unsafe.Pointer(classGUID)), uintptr(unsafe.Pointer(className)), uintptr(classNameSize), uintptr(unsafe.Pointer(requiredSize)), uintptr(unsafe.Pointer(machineName)), uintptr(reserved))
3949
	if r1 == 0 {
3950
		err = errnoErr(e1)
3951
	}
3952
	return
3953
}
3954

3955
func setupDiCreateDeviceInfoListEx(classGUID *GUID, hwndParent uintptr, machineName *uint16, reserved uintptr) (handle DevInfo, err error) {
3956
	r0, _, e1 := syscall.SyscallN(procSetupDiCreateDeviceInfoListExW.Addr(), uintptr(unsafe.Pointer(classGUID)), uintptr(hwndParent), uintptr(unsafe.Pointer(machineName)), uintptr(reserved))
3957
	handle = DevInfo(r0)
3958
	if handle == DevInfo(InvalidHandle) {
3959
		err = errnoErr(e1)
3960
	}
3961
	return
3962
}
3963

3964
func setupDiCreateDeviceInfo(deviceInfoSet DevInfo, DeviceName *uint16, classGUID *GUID, DeviceDescription *uint16, hwndParent uintptr, CreationFlags DICD, deviceInfoData *DevInfoData) (err error) {
3965
	r1, _, e1 := syscall.SyscallN(procSetupDiCreateDeviceInfoW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(DeviceName)), uintptr(unsafe.Pointer(classGUID)), uintptr(unsafe.Pointer(DeviceDescription)), uintptr(hwndParent), uintptr(CreationFlags), uintptr(unsafe.Pointer(deviceInfoData)))
3966
	if r1 == 0 {
3967
		err = errnoErr(e1)
3968
	}
3969
	return
3970
}
3971

3972
func SetupDiDestroyDeviceInfoList(deviceInfoSet DevInfo) (err error) {
3973
	r1, _, e1 := syscall.SyscallN(procSetupDiDestroyDeviceInfoList.Addr(), uintptr(deviceInfoSet))
3974
	if r1 == 0 {
3975
		err = errnoErr(e1)
3976
	}
3977
	return
3978
}
3979

3980
func SetupDiDestroyDriverInfoList(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverType SPDIT) (err error) {
3981
	r1, _, e1 := syscall.SyscallN(procSetupDiDestroyDriverInfoList.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(driverType))
3982
	if r1 == 0 {
3983
		err = errnoErr(e1)
3984
	}
3985
	return
3986
}
3987

3988
func setupDiEnumDeviceInfo(deviceInfoSet DevInfo, memberIndex uint32, deviceInfoData *DevInfoData) (err error) {
3989
	r1, _, e1 := syscall.SyscallN(procSetupDiEnumDeviceInfo.Addr(), uintptr(deviceInfoSet), uintptr(memberIndex), uintptr(unsafe.Pointer(deviceInfoData)))
3990
	if r1 == 0 {
3991
		err = errnoErr(e1)
3992
	}
3993
	return
3994
}
3995

3996
func setupDiEnumDriverInfo(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverType SPDIT, memberIndex uint32, driverInfoData *DrvInfoData) (err error) {
3997
	r1, _, e1 := syscall.SyscallN(procSetupDiEnumDriverInfoW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(driverType), uintptr(memberIndex), uintptr(unsafe.Pointer(driverInfoData)))
3998
	if r1 == 0 {
3999
		err = errnoErr(e1)
4000
	}
4001
	return
4002
}
4003

4004
func setupDiGetClassDevsEx(classGUID *GUID, Enumerator *uint16, hwndParent uintptr, Flags DIGCF, deviceInfoSet DevInfo, machineName *uint16, reserved uintptr) (handle DevInfo, err error) {
4005
	r0, _, e1 := syscall.SyscallN(procSetupDiGetClassDevsExW.Addr(), uintptr(unsafe.Pointer(classGUID)), uintptr(unsafe.Pointer(Enumerator)), uintptr(hwndParent), uintptr(Flags), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(machineName)), uintptr(reserved))
4006
	handle = DevInfo(r0)
4007
	if handle == DevInfo(InvalidHandle) {
4008
		err = errnoErr(e1)
4009
	}
4010
	return
4011
}
4012

4013
func SetupDiGetClassInstallParams(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, classInstallParams *ClassInstallHeader, classInstallParamsSize uint32, requiredSize *uint32) (err error) {
4014
	r1, _, e1 := syscall.SyscallN(procSetupDiGetClassInstallParamsW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(classInstallParams)), uintptr(classInstallParamsSize), uintptr(unsafe.Pointer(requiredSize)))
4015
	if r1 == 0 {
4016
		err = errnoErr(e1)
4017
	}
4018
	return
4019
}
4020

4021
func setupDiGetDeviceInfoListDetail(deviceInfoSet DevInfo, deviceInfoSetDetailData *DevInfoListDetailData) (err error) {
4022
	r1, _, e1 := syscall.SyscallN(procSetupDiGetDeviceInfoListDetailW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoSetDetailData)))
4023
	if r1 == 0 {
4024
		err = errnoErr(e1)
4025
	}
4026
	return
4027
}
4028

4029
func setupDiGetDeviceInstallParams(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, deviceInstallParams *DevInstallParams) (err error) {
4030
	r1, _, e1 := syscall.SyscallN(procSetupDiGetDeviceInstallParamsW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(deviceInstallParams)))
4031
	if r1 == 0 {
4032
		err = errnoErr(e1)
4033
	}
4034
	return
4035
}
4036

4037
func setupDiGetDeviceInstanceId(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, instanceId *uint16, instanceIdSize uint32, instanceIdRequiredSize *uint32) (err error) {
4038
	r1, _, e1 := syscall.SyscallN(procSetupDiGetDeviceInstanceIdW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(instanceId)), uintptr(instanceIdSize), uintptr(unsafe.Pointer(instanceIdRequiredSize)))
4039
	if r1 == 0 {
4040
		err = errnoErr(e1)
4041
	}
4042
	return
4043
}
4044

4045
func setupDiGetDeviceProperty(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, propertyKey *DEVPROPKEY, propertyType *DEVPROPTYPE, propertyBuffer *byte, propertyBufferSize uint32, requiredSize *uint32, flags uint32) (err error) {
4046
	r1, _, e1 := syscall.SyscallN(procSetupDiGetDevicePropertyW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(propertyKey)), uintptr(unsafe.Pointer(propertyType)), uintptr(unsafe.Pointer(propertyBuffer)), uintptr(propertyBufferSize), uintptr(unsafe.Pointer(requiredSize)), uintptr(flags))
4047
	if r1 == 0 {
4048
		err = errnoErr(e1)
4049
	}
4050
	return
4051
}
4052

4053
func setupDiGetDeviceRegistryProperty(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, property SPDRP, propertyRegDataType *uint32, propertyBuffer *byte, propertyBufferSize uint32, requiredSize *uint32) (err error) {
4054
	r1, _, e1 := syscall.SyscallN(procSetupDiGetDeviceRegistryPropertyW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(property), uintptr(unsafe.Pointer(propertyRegDataType)), uintptr(unsafe.Pointer(propertyBuffer)), uintptr(propertyBufferSize), uintptr(unsafe.Pointer(requiredSize)))
4055
	if r1 == 0 {
4056
		err = errnoErr(e1)
4057
	}
4058
	return
4059
}
4060

4061
func setupDiGetDriverInfoDetail(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverInfoData *DrvInfoData, driverInfoDetailData *DrvInfoDetailData, driverInfoDetailDataSize uint32, requiredSize *uint32) (err error) {
4062
	r1, _, e1 := syscall.SyscallN(procSetupDiGetDriverInfoDetailW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(driverInfoData)), uintptr(unsafe.Pointer(driverInfoDetailData)), uintptr(driverInfoDetailDataSize), uintptr(unsafe.Pointer(requiredSize)))
4063
	if r1 == 0 {
4064
		err = errnoErr(e1)
4065
	}
4066
	return
4067
}
4068

4069
func setupDiGetSelectedDevice(deviceInfoSet DevInfo, deviceInfoData *DevInfoData) (err error) {
4070
	r1, _, e1 := syscall.SyscallN(procSetupDiGetSelectedDevice.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)))
4071
	if r1 == 0 {
4072
		err = errnoErr(e1)
4073
	}
4074
	return
4075
}
4076

4077
func setupDiGetSelectedDriver(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverInfoData *DrvInfoData) (err error) {
4078
	r1, _, e1 := syscall.SyscallN(procSetupDiGetSelectedDriverW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(driverInfoData)))
4079
	if r1 == 0 {
4080
		err = errnoErr(e1)
4081
	}
4082
	return
4083
}
4084

4085
func SetupDiOpenDevRegKey(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, Scope DICS_FLAG, HwProfile uint32, KeyType DIREG, samDesired uint32) (key Handle, err error) {
4086
	r0, _, e1 := syscall.SyscallN(procSetupDiOpenDevRegKey.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(Scope), uintptr(HwProfile), uintptr(KeyType), uintptr(samDesired))
4087
	key = Handle(r0)
4088
	if key == InvalidHandle {
4089
		err = errnoErr(e1)
4090
	}
4091
	return
4092
}
4093

4094
func SetupDiSetClassInstallParams(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, classInstallParams *ClassInstallHeader, classInstallParamsSize uint32) (err error) {
4095
	r1, _, e1 := syscall.SyscallN(procSetupDiSetClassInstallParamsW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(classInstallParams)), uintptr(classInstallParamsSize))
4096
	if r1 == 0 {
4097
		err = errnoErr(e1)
4098
	}
4099
	return
4100
}
4101

4102
func SetupDiSetDeviceInstallParams(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, deviceInstallParams *DevInstallParams) (err error) {
4103
	r1, _, e1 := syscall.SyscallN(procSetupDiSetDeviceInstallParamsW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(deviceInstallParams)))
4104
	if r1 == 0 {
4105
		err = errnoErr(e1)
4106
	}
4107
	return
4108
}
4109

4110
func setupDiSetDeviceRegistryProperty(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, property SPDRP, propertyBuffer *byte, propertyBufferSize uint32) (err error) {
4111
	r1, _, e1 := syscall.SyscallN(procSetupDiSetDeviceRegistryPropertyW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(property), uintptr(unsafe.Pointer(propertyBuffer)), uintptr(propertyBufferSize))
4112
	if r1 == 0 {
4113
		err = errnoErr(e1)
4114
	}
4115
	return
4116
}
4117

4118
func SetupDiSetSelectedDevice(deviceInfoSet DevInfo, deviceInfoData *DevInfoData) (err error) {
4119
	r1, _, e1 := syscall.SyscallN(procSetupDiSetSelectedDevice.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)))
4120
	if r1 == 0 {
4121
		err = errnoErr(e1)
4122
	}
4123
	return
4124
}
4125

4126
func SetupDiSetSelectedDriver(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverInfoData *DrvInfoData) (err error) {
4127
	r1, _, e1 := syscall.SyscallN(procSetupDiSetSelectedDriverW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(driverInfoData)))
4128
	if r1 == 0 {
4129
		err = errnoErr(e1)
4130
	}
4131
	return
4132
}
4133

4134
func setupUninstallOEMInf(infFileName *uint16, flags SUOI, reserved uintptr) (err error) {
4135
	r1, _, e1 := syscall.SyscallN(procSetupUninstallOEMInfW.Addr(), uintptr(unsafe.Pointer(infFileName)), uintptr(flags), uintptr(reserved))
4136
	if r1 == 0 {
4137
		err = errnoErr(e1)
4138
	}
4139
	return
4140
}
4141

4142
func commandLineToArgv(cmd *uint16, argc *int32) (argv **uint16, err error) {
4143
	r0, _, e1 := syscall.SyscallN(procCommandLineToArgvW.Addr(), uintptr(unsafe.Pointer(cmd)), uintptr(unsafe.Pointer(argc)))
4144
	argv = (**uint16)(unsafe.Pointer(r0))
4145
	if argv == nil {
4146
		err = errnoErr(e1)
4147
	}
4148
	return
4149
}
4150

4151
func shGetKnownFolderPath(id *KNOWNFOLDERID, flags uint32, token Token, path **uint16) (ret error) {
4152
	r0, _, _ := syscall.SyscallN(procSHGetKnownFolderPath.Addr(), uintptr(unsafe.Pointer(id)), uintptr(flags), uintptr(token), uintptr(unsafe.Pointer(path)))
4153
	if r0 != 0 {
4154
		ret = syscall.Errno(r0)
4155
	}
4156
	return
4157
}
4158

4159
func ShellExecute(hwnd Handle, verb *uint16, file *uint16, args *uint16, cwd *uint16, showCmd int32) (err error) {
4160
	r1, _, e1 := syscall.SyscallN(procShellExecuteW.Addr(), uintptr(hwnd), uintptr(unsafe.Pointer(verb)), uintptr(unsafe.Pointer(file)), uintptr(unsafe.Pointer(args)), uintptr(unsafe.Pointer(cwd)), uintptr(showCmd))
4161
	if r1 <= 32 {
4162
		err = errnoErr(e1)
4163
	}
4164
	return
4165
}
4166

4167
func EnumChildWindows(hwnd HWND, enumFunc uintptr, param unsafe.Pointer) {
4168
	syscall.SyscallN(procEnumChildWindows.Addr(), uintptr(hwnd), uintptr(enumFunc), uintptr(param))
4169
	return
4170
}
4171

4172
func EnumWindows(enumFunc uintptr, param unsafe.Pointer) (err error) {
4173
	r1, _, e1 := syscall.SyscallN(procEnumWindows.Addr(), uintptr(enumFunc), uintptr(param))
4174
	if r1 == 0 {
4175
		err = errnoErr(e1)
4176
	}
4177
	return
4178
}
4179

4180
func ExitWindowsEx(flags uint32, reason uint32) (err error) {
4181
	r1, _, e1 := syscall.SyscallN(procExitWindowsEx.Addr(), uintptr(flags), uintptr(reason))
4182
	if r1 == 0 {
4183
		err = errnoErr(e1)
4184
	}
4185
	return
4186
}
4187

4188
func GetClassName(hwnd HWND, className *uint16, maxCount int32) (copied int32, err error) {
4189
	r0, _, e1 := syscall.SyscallN(procGetClassNameW.Addr(), uintptr(hwnd), uintptr(unsafe.Pointer(className)), uintptr(maxCount))
4190
	copied = int32(r0)
4191
	if copied == 0 {
4192
		err = errnoErr(e1)
4193
	}
4194
	return
4195
}
4196

4197
func GetDesktopWindow() (hwnd HWND) {
4198
	r0, _, _ := syscall.SyscallN(procGetDesktopWindow.Addr())
4199
	hwnd = HWND(r0)
4200
	return
4201
}
4202

4203
func GetForegroundWindow() (hwnd HWND) {
4204
	r0, _, _ := syscall.SyscallN(procGetForegroundWindow.Addr())
4205
	hwnd = HWND(r0)
4206
	return
4207
}
4208

4209
func GetGUIThreadInfo(thread uint32, info *GUIThreadInfo) (err error) {
4210
	r1, _, e1 := syscall.SyscallN(procGetGUIThreadInfo.Addr(), uintptr(thread), uintptr(unsafe.Pointer(info)))
4211
	if r1 == 0 {
4212
		err = errnoErr(e1)
4213
	}
4214
	return
4215
}
4216

4217
func GetKeyboardLayout(tid uint32) (hkl Handle) {
4218
	r0, _, _ := syscall.SyscallN(procGetKeyboardLayout.Addr(), uintptr(tid))
4219
	hkl = Handle(r0)
4220
	return
4221
}
4222

4223
func GetShellWindow() (shellWindow HWND) {
4224
	r0, _, _ := syscall.SyscallN(procGetShellWindow.Addr())
4225
	shellWindow = HWND(r0)
4226
	return
4227
}
4228

4229
func GetWindowThreadProcessId(hwnd HWND, pid *uint32) (tid uint32, err error) {
4230
	r0, _, e1 := syscall.SyscallN(procGetWindowThreadProcessId.Addr(), uintptr(hwnd), uintptr(unsafe.Pointer(pid)))
4231
	tid = uint32(r0)
4232
	if tid == 0 {
4233
		err = errnoErr(e1)
4234
	}
4235
	return
4236
}
4237

4238
func IsWindow(hwnd HWND) (isWindow bool) {
4239
	r0, _, _ := syscall.SyscallN(procIsWindow.Addr(), uintptr(hwnd))
4240
	isWindow = r0 != 0
4241
	return
4242
}
4243

4244
func IsWindowUnicode(hwnd HWND) (isUnicode bool) {
4245
	r0, _, _ := syscall.SyscallN(procIsWindowUnicode.Addr(), uintptr(hwnd))
4246
	isUnicode = r0 != 0
4247
	return
4248
}
4249

4250
func IsWindowVisible(hwnd HWND) (isVisible bool) {
4251
	r0, _, _ := syscall.SyscallN(procIsWindowVisible.Addr(), uintptr(hwnd))
4252
	isVisible = r0 != 0
4253
	return
4254
}
4255

4256
func LoadKeyboardLayout(name *uint16, flags uint32) (hkl Handle, err error) {
4257
	r0, _, e1 := syscall.SyscallN(procLoadKeyboardLayoutW.Addr(), uintptr(unsafe.Pointer(name)), uintptr(flags))
4258
	hkl = Handle(r0)
4259
	if hkl == 0 {
4260
		err = errnoErr(e1)
4261
	}
4262
	return
4263
}
4264

4265
func MessageBox(hwnd HWND, text *uint16, caption *uint16, boxtype uint32) (ret int32, err error) {
4266
	r0, _, e1 := syscall.SyscallN(procMessageBoxW.Addr(), uintptr(hwnd), uintptr(unsafe.Pointer(text)), uintptr(unsafe.Pointer(caption)), uintptr(boxtype))
4267
	ret = int32(r0)
4268
	if ret == 0 {
4269
		err = errnoErr(e1)
4270
	}
4271
	return
4272
}
4273

4274
func ToUnicodeEx(vkey uint32, scancode uint32, keystate *byte, pwszBuff *uint16, cchBuff int32, flags uint32, hkl Handle) (ret int32) {
4275
	r0, _, _ := syscall.SyscallN(procToUnicodeEx.Addr(), uintptr(vkey), uintptr(scancode), uintptr(unsafe.Pointer(keystate)), uintptr(unsafe.Pointer(pwszBuff)), uintptr(cchBuff), uintptr(flags), uintptr(hkl))
4276
	ret = int32(r0)
4277
	return
4278
}
4279

4280
func UnloadKeyboardLayout(hkl Handle) (err error) {
4281
	r1, _, e1 := syscall.SyscallN(procUnloadKeyboardLayout.Addr(), uintptr(hkl))
4282
	if r1 == 0 {
4283
		err = errnoErr(e1)
4284
	}
4285
	return
4286
}
4287

4288
func CreateEnvironmentBlock(block **uint16, token Token, inheritExisting bool) (err error) {
4289
	var _p0 uint32
4290
	if inheritExisting {
4291
		_p0 = 1
4292
	}
4293
	r1, _, e1 := syscall.SyscallN(procCreateEnvironmentBlock.Addr(), uintptr(unsafe.Pointer(block)), uintptr(token), uintptr(_p0))
4294
	if r1 == 0 {
4295
		err = errnoErr(e1)
4296
	}
4297
	return
4298
}
4299

4300
func DestroyEnvironmentBlock(block *uint16) (err error) {
4301
	r1, _, e1 := syscall.SyscallN(procDestroyEnvironmentBlock.Addr(), uintptr(unsafe.Pointer(block)))
4302
	if r1 == 0 {
4303
		err = errnoErr(e1)
4304
	}
4305
	return
4306
}
4307

4308
func GetUserProfileDirectory(t Token, dir *uint16, dirLen *uint32) (err error) {
4309
	r1, _, e1 := syscall.SyscallN(procGetUserProfileDirectoryW.Addr(), uintptr(t), uintptr(unsafe.Pointer(dir)), uintptr(unsafe.Pointer(dirLen)))
4310
	if r1 == 0 {
4311
		err = errnoErr(e1)
4312
	}
4313
	return
4314
}
4315

4316
func GetFileVersionInfoSize(filename string, zeroHandle *Handle) (bufSize uint32, err error) {
4317
	var _p0 *uint16
4318
	_p0, err = syscall.UTF16PtrFromString(filename)
4319
	if err != nil {
4320
		return
4321
	}
4322
	return _GetFileVersionInfoSize(_p0, zeroHandle)
4323
}
4324

4325
func _GetFileVersionInfoSize(filename *uint16, zeroHandle *Handle) (bufSize uint32, err error) {
4326
	r0, _, e1 := syscall.SyscallN(procGetFileVersionInfoSizeW.Addr(), uintptr(unsafe.Pointer(filename)), uintptr(unsafe.Pointer(zeroHandle)))
4327
	bufSize = uint32(r0)
4328
	if bufSize == 0 {
4329
		err = errnoErr(e1)
4330
	}
4331
	return
4332
}
4333

4334
func GetFileVersionInfo(filename string, handle uint32, bufSize uint32, buffer unsafe.Pointer) (err error) {
4335
	var _p0 *uint16
4336
	_p0, err = syscall.UTF16PtrFromString(filename)
4337
	if err != nil {
4338
		return
4339
	}
4340
	return _GetFileVersionInfo(_p0, handle, bufSize, buffer)
4341
}
4342

4343
func _GetFileVersionInfo(filename *uint16, handle uint32, bufSize uint32, buffer unsafe.Pointer) (err error) {
4344
	r1, _, e1 := syscall.SyscallN(procGetFileVersionInfoW.Addr(), uintptr(unsafe.Pointer(filename)), uintptr(handle), uintptr(bufSize), uintptr(buffer))
4345
	if r1 == 0 {
4346
		err = errnoErr(e1)
4347
	}
4348
	return
4349
}
4350

4351
func VerQueryValue(block unsafe.Pointer, subBlock string, pointerToBufferPointer unsafe.Pointer, bufSize *uint32) (err error) {
4352
	var _p0 *uint16
4353
	_p0, err = syscall.UTF16PtrFromString(subBlock)
4354
	if err != nil {
4355
		return
4356
	}
4357
	return _VerQueryValue(block, _p0, pointerToBufferPointer, bufSize)
4358
}
4359

4360
func _VerQueryValue(block unsafe.Pointer, subBlock *uint16, pointerToBufferPointer unsafe.Pointer, bufSize *uint32) (err error) {
4361
	r1, _, e1 := syscall.SyscallN(procVerQueryValueW.Addr(), uintptr(block), uintptr(unsafe.Pointer(subBlock)), uintptr(pointerToBufferPointer), uintptr(unsafe.Pointer(bufSize)))
4362
	if r1 == 0 {
4363
		err = errnoErr(e1)
4364
	}
4365
	return
4366
}
4367

4368
func TimeBeginPeriod(period uint32) (err error) {
4369
	r1, _, e1 := syscall.SyscallN(proctimeBeginPeriod.Addr(), uintptr(period))
4370
	if r1 != 0 {
4371
		err = errnoErr(e1)
4372
	}
4373
	return
4374
}
4375

4376
func TimeEndPeriod(period uint32) (err error) {
4377
	r1, _, e1 := syscall.SyscallN(proctimeEndPeriod.Addr(), uintptr(period))
4378
	if r1 != 0 {
4379
		err = errnoErr(e1)
4380
	}
4381
	return
4382
}
4383

4384
func WinVerifyTrustEx(hwnd HWND, actionId *GUID, data *WinTrustData) (ret error) {
4385
	r0, _, _ := syscall.SyscallN(procWinVerifyTrustEx.Addr(), uintptr(hwnd), uintptr(unsafe.Pointer(actionId)), uintptr(unsafe.Pointer(data)))
4386
	if r0 != 0 {
4387
		ret = syscall.Errno(r0)
4388
	}
4389
	return
4390
}
4391

4392
func FreeAddrInfoW(addrinfo *AddrinfoW) {
4393
	syscall.SyscallN(procFreeAddrInfoW.Addr(), uintptr(unsafe.Pointer(addrinfo)))
4394
	return
4395
}
4396

4397
func GetAddrInfoW(nodename *uint16, servicename *uint16, hints *AddrinfoW, result **AddrinfoW) (sockerr error) {
4398
	r0, _, _ := syscall.SyscallN(procGetAddrInfoW.Addr(), uintptr(unsafe.Pointer(nodename)), uintptr(unsafe.Pointer(servicename)), uintptr(unsafe.Pointer(hints)), uintptr(unsafe.Pointer(result)))
4399
	if r0 != 0 {
4400
		sockerr = syscall.Errno(r0)
4401
	}
4402
	return
4403
}
4404

4405
func WSACleanup() (err error) {
4406
	r1, _, e1 := syscall.SyscallN(procWSACleanup.Addr())
4407
	if r1 == socket_error {
4408
		err = errnoErr(e1)
4409
	}
4410
	return
4411
}
4412

4413
func WSADuplicateSocket(s Handle, processID uint32, info *WSAProtocolInfo) (err error) {
4414
	r1, _, e1 := syscall.SyscallN(procWSADuplicateSocketW.Addr(), uintptr(s), uintptr(processID), uintptr(unsafe.Pointer(info)))
4415
	if r1 != 0 {
4416
		err = errnoErr(e1)
4417
	}
4418
	return
4419
}
4420

4421
func WSAEnumProtocols(protocols *int32, protocolBuffer *WSAProtocolInfo, bufferLength *uint32) (n int32, err error) {
4422
	r0, _, e1 := syscall.SyscallN(procWSAEnumProtocolsW.Addr(), uintptr(unsafe.Pointer(protocols)), uintptr(unsafe.Pointer(protocolBuffer)), uintptr(unsafe.Pointer(bufferLength)))
4423
	n = int32(r0)
4424
	if n == -1 {
4425
		err = errnoErr(e1)
4426
	}
4427
	return
4428
}
4429

4430
func WSAGetOverlappedResult(h Handle, o *Overlapped, bytes *uint32, wait bool, flags *uint32) (err error) {
4431
	var _p0 uint32
4432
	if wait {
4433
		_p0 = 1
4434
	}
4435
	r1, _, e1 := syscall.SyscallN(procWSAGetOverlappedResult.Addr(), uintptr(h), uintptr(unsafe.Pointer(o)), uintptr(unsafe.Pointer(bytes)), uintptr(_p0), uintptr(unsafe.Pointer(flags)))
4436
	if r1 == 0 {
4437
		err = errnoErr(e1)
4438
	}
4439
	return
4440
}
4441

4442
func WSAIoctl(s Handle, iocc uint32, inbuf *byte, cbif uint32, outbuf *byte, cbob uint32, cbbr *uint32, overlapped *Overlapped, completionRoutine uintptr) (err error) {
4443
	r1, _, e1 := syscall.SyscallN(procWSAIoctl.Addr(), uintptr(s), uintptr(iocc), uintptr(unsafe.Pointer(inbuf)), uintptr(cbif), uintptr(unsafe.Pointer(outbuf)), uintptr(cbob), uintptr(unsafe.Pointer(cbbr)), uintptr(unsafe.Pointer(overlapped)), uintptr(completionRoutine))
4444
	if r1 == socket_error {
4445
		err = errnoErr(e1)
4446
	}
4447
	return
4448
}
4449

4450
func WSALookupServiceBegin(querySet *WSAQUERYSET, flags uint32, handle *Handle) (err error) {
4451
	r1, _, e1 := syscall.SyscallN(procWSALookupServiceBeginW.Addr(), uintptr(unsafe.Pointer(querySet)), uintptr(flags), uintptr(unsafe.Pointer(handle)))
4452
	if r1 == socket_error {
4453
		err = errnoErr(e1)
4454
	}
4455
	return
4456
}
4457

4458
func WSALookupServiceEnd(handle Handle) (err error) {
4459
	r1, _, e1 := syscall.SyscallN(procWSALookupServiceEnd.Addr(), uintptr(handle))
4460
	if r1 == socket_error {
4461
		err = errnoErr(e1)
4462
	}
4463
	return
4464
}
4465

4466
func WSALookupServiceNext(handle Handle, flags uint32, size *int32, querySet *WSAQUERYSET) (err error) {
4467
	r1, _, e1 := syscall.SyscallN(procWSALookupServiceNextW.Addr(), uintptr(handle), uintptr(flags), uintptr(unsafe.Pointer(size)), uintptr(unsafe.Pointer(querySet)))
4468
	if r1 == socket_error {
4469
		err = errnoErr(e1)
4470
	}
4471
	return
4472
}
4473

4474
func WSARecv(s Handle, bufs *WSABuf, bufcnt uint32, recvd *uint32, flags *uint32, overlapped *Overlapped, croutine *byte) (err error) {
4475
	r1, _, e1 := syscall.SyscallN(procWSARecv.Addr(), uintptr(s), uintptr(unsafe.Pointer(bufs)), uintptr(bufcnt), uintptr(unsafe.Pointer(recvd)), uintptr(unsafe.Pointer(flags)), uintptr(unsafe.Pointer(overlapped)), uintptr(unsafe.Pointer(croutine)))
4476
	if r1 == socket_error {
4477
		err = errnoErr(e1)
4478
	}
4479
	return
4480
}
4481

4482
func WSARecvFrom(s Handle, bufs *WSABuf, bufcnt uint32, recvd *uint32, flags *uint32, from *RawSockaddrAny, fromlen *int32, overlapped *Overlapped, croutine *byte) (err error) {
4483
	r1, _, e1 := syscall.SyscallN(procWSARecvFrom.Addr(), uintptr(s), uintptr(unsafe.Pointer(bufs)), uintptr(bufcnt), uintptr(unsafe.Pointer(recvd)), uintptr(unsafe.Pointer(flags)), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)), uintptr(unsafe.Pointer(overlapped)), uintptr(unsafe.Pointer(croutine)))
4484
	if r1 == socket_error {
4485
		err = errnoErr(e1)
4486
	}
4487
	return
4488
}
4489

4490
func WSASend(s Handle, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, overlapped *Overlapped, croutine *byte) (err error) {
4491
	r1, _, e1 := syscall.SyscallN(procWSASend.Addr(), uintptr(s), uintptr(unsafe.Pointer(bufs)), uintptr(bufcnt), uintptr(unsafe.Pointer(sent)), uintptr(flags), uintptr(unsafe.Pointer(overlapped)), uintptr(unsafe.Pointer(croutine)))
4492
	if r1 == socket_error {
4493
		err = errnoErr(e1)
4494
	}
4495
	return
4496
}
4497

4498
func WSASendTo(s Handle, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, to *RawSockaddrAny, tolen int32, overlapped *Overlapped, croutine *byte) (err error) {
4499
	r1, _, e1 := syscall.SyscallN(procWSASendTo.Addr(), uintptr(s), uintptr(unsafe.Pointer(bufs)), uintptr(bufcnt), uintptr(unsafe.Pointer(sent)), uintptr(flags), uintptr(unsafe.Pointer(to)), uintptr(tolen), uintptr(unsafe.Pointer(overlapped)), uintptr(unsafe.Pointer(croutine)))
4500
	if r1 == socket_error {
4501
		err = errnoErr(e1)
4502
	}
4503
	return
4504
}
4505

4506
func WSASocket(af int32, typ int32, protocol int32, protoInfo *WSAProtocolInfo, group uint32, flags uint32) (handle Handle, err error) {
4507
	r0, _, e1 := syscall.SyscallN(procWSASocketW.Addr(), uintptr(af), uintptr(typ), uintptr(protocol), uintptr(unsafe.Pointer(protoInfo)), uintptr(group), uintptr(flags))
4508
	handle = Handle(r0)
4509
	if handle == InvalidHandle {
4510
		err = errnoErr(e1)
4511
	}
4512
	return
4513
}
4514

4515
func WSAStartup(verreq uint32, data *WSAData) (sockerr error) {
4516
	r0, _, _ := syscall.SyscallN(procWSAStartup.Addr(), uintptr(verreq), uintptr(unsafe.Pointer(data)))
4517
	if r0 != 0 {
4518
		sockerr = syscall.Errno(r0)
4519
	}
4520
	return
4521
}
4522

4523
func bind(s Handle, name unsafe.Pointer, namelen int32) (err error) {
4524
	r1, _, e1 := syscall.SyscallN(procbind.Addr(), uintptr(s), uintptr(name), uintptr(namelen))
4525
	if r1 == socket_error {
4526
		err = errnoErr(e1)
4527
	}
4528
	return
4529
}
4530

4531
func Closesocket(s Handle) (err error) {
4532
	r1, _, e1 := syscall.SyscallN(procclosesocket.Addr(), uintptr(s))
4533
	if r1 == socket_error {
4534
		err = errnoErr(e1)
4535
	}
4536
	return
4537
}
4538

4539
func connect(s Handle, name unsafe.Pointer, namelen int32) (err error) {
4540
	r1, _, e1 := syscall.SyscallN(procconnect.Addr(), uintptr(s), uintptr(name), uintptr(namelen))
4541
	if r1 == socket_error {
4542
		err = errnoErr(e1)
4543
	}
4544
	return
4545
}
4546

4547
func GetHostByName(name string) (h *Hostent, err error) {
4548
	var _p0 *byte
4549
	_p0, err = syscall.BytePtrFromString(name)
4550
	if err != nil {
4551
		return
4552
	}
4553
	return _GetHostByName(_p0)
4554
}
4555

4556
func _GetHostByName(name *byte) (h *Hostent, err error) {
4557
	r0, _, e1 := syscall.SyscallN(procgethostbyname.Addr(), uintptr(unsafe.Pointer(name)))
4558
	h = (*Hostent)(unsafe.Pointer(r0))
4559
	if h == nil {
4560
		err = errnoErr(e1)
4561
	}
4562
	return
4563
}
4564

4565
func getpeername(s Handle, rsa *RawSockaddrAny, addrlen *int32) (err error) {
4566
	r1, _, e1 := syscall.SyscallN(procgetpeername.Addr(), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
4567
	if r1 == socket_error {
4568
		err = errnoErr(e1)
4569
	}
4570
	return
4571
}
4572

4573
func GetProtoByName(name string) (p *Protoent, err error) {
4574
	var _p0 *byte
4575
	_p0, err = syscall.BytePtrFromString(name)
4576
	if err != nil {
4577
		return
4578
	}
4579
	return _GetProtoByName(_p0)
4580
}
4581

4582
func _GetProtoByName(name *byte) (p *Protoent, err error) {
4583
	r0, _, e1 := syscall.SyscallN(procgetprotobyname.Addr(), uintptr(unsafe.Pointer(name)))
4584
	p = (*Protoent)(unsafe.Pointer(r0))
4585
	if p == nil {
4586
		err = errnoErr(e1)
4587
	}
4588
	return
4589
}
4590

4591
func GetServByName(name string, proto string) (s *Servent, err error) {
4592
	var _p0 *byte
4593
	_p0, err = syscall.BytePtrFromString(name)
4594
	if err != nil {
4595
		return
4596
	}
4597
	var _p1 *byte
4598
	_p1, err = syscall.BytePtrFromString(proto)
4599
	if err != nil {
4600
		return
4601
	}
4602
	return _GetServByName(_p0, _p1)
4603
}
4604

4605
func _GetServByName(name *byte, proto *byte) (s *Servent, err error) {
4606
	r0, _, e1 := syscall.SyscallN(procgetservbyname.Addr(), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(proto)))
4607
	s = (*Servent)(unsafe.Pointer(r0))
4608
	if s == nil {
4609
		err = errnoErr(e1)
4610
	}
4611
	return
4612
}
4613

4614
func getsockname(s Handle, rsa *RawSockaddrAny, addrlen *int32) (err error) {
4615
	r1, _, e1 := syscall.SyscallN(procgetsockname.Addr(), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
4616
	if r1 == socket_error {
4617
		err = errnoErr(e1)
4618
	}
4619
	return
4620
}
4621

4622
func Getsockopt(s Handle, level int32, optname int32, optval *byte, optlen *int32) (err error) {
4623
	r1, _, e1 := syscall.SyscallN(procgetsockopt.Addr(), uintptr(s), uintptr(level), uintptr(optname), uintptr(unsafe.Pointer(optval)), uintptr(unsafe.Pointer(optlen)))
4624
	if r1 == socket_error {
4625
		err = errnoErr(e1)
4626
	}
4627
	return
4628
}
4629

4630
func listen(s Handle, backlog int32) (err error) {
4631
	r1, _, e1 := syscall.SyscallN(proclisten.Addr(), uintptr(s), uintptr(backlog))
4632
	if r1 == socket_error {
4633
		err = errnoErr(e1)
4634
	}
4635
	return
4636
}
4637

4638
func Ntohs(netshort uint16) (u uint16) {
4639
	r0, _, _ := syscall.SyscallN(procntohs.Addr(), uintptr(netshort))
4640
	u = uint16(r0)
4641
	return
4642
}
4643

4644
func recvfrom(s Handle, buf []byte, flags int32, from *RawSockaddrAny, fromlen *int32) (n int32, err error) {
4645
	var _p0 *byte
4646
	if len(buf) > 0 {
4647
		_p0 = &buf[0]
4648
	}
4649
	r0, _, e1 := syscall.SyscallN(procrecvfrom.Addr(), uintptr(s), uintptr(unsafe.Pointer(_p0)), uintptr(len(buf)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
4650
	n = int32(r0)
4651
	if n == -1 {
4652
		err = errnoErr(e1)
4653
	}
4654
	return
4655
}
4656

4657
func sendto(s Handle, buf []byte, flags int32, to unsafe.Pointer, tolen int32) (err error) {
4658
	var _p0 *byte
4659
	if len(buf) > 0 {
4660
		_p0 = &buf[0]
4661
	}
4662
	r1, _, e1 := syscall.SyscallN(procsendto.Addr(), uintptr(s), uintptr(unsafe.Pointer(_p0)), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(tolen))
4663
	if r1 == socket_error {
4664
		err = errnoErr(e1)
4665
	}
4666
	return
4667
}
4668

4669
func Setsockopt(s Handle, level int32, optname int32, optval *byte, optlen int32) (err error) {
4670
	r1, _, e1 := syscall.SyscallN(procsetsockopt.Addr(), uintptr(s), uintptr(level), uintptr(optname), uintptr(unsafe.Pointer(optval)), uintptr(optlen))
4671
	if r1 == socket_error {
4672
		err = errnoErr(e1)
4673
	}
4674
	return
4675
}
4676

4677
func shutdown(s Handle, how int32) (err error) {
4678
	r1, _, e1 := syscall.SyscallN(procshutdown.Addr(), uintptr(s), uintptr(how))
4679
	if r1 == socket_error {
4680
		err = errnoErr(e1)
4681
	}
4682
	return
4683
}
4684

4685
func socket(af int32, typ int32, protocol int32) (handle Handle, err error) {
4686
	r0, _, e1 := syscall.SyscallN(procsocket.Addr(), uintptr(af), uintptr(typ), uintptr(protocol))
4687
	handle = Handle(r0)
4688
	if handle == InvalidHandle {
4689
		err = errnoErr(e1)
4690
	}
4691
	return
4692
}
4693

4694
func WTSEnumerateSessions(handle Handle, reserved uint32, version uint32, sessions **WTS_SESSION_INFO, count *uint32) (err error) {
4695
	r1, _, e1 := syscall.SyscallN(procWTSEnumerateSessionsW.Addr(), uintptr(handle), uintptr(reserved), uintptr(version), uintptr(unsafe.Pointer(sessions)), uintptr(unsafe.Pointer(count)))
4696
	if r1 == 0 {
4697
		err = errnoErr(e1)
4698
	}
4699
	return
4700
}
4701

4702
func WTSFreeMemory(ptr uintptr) {
4703
	syscall.SyscallN(procWTSFreeMemory.Addr(), uintptr(ptr))
4704
	return
4705
}
4706

4707
func WTSQueryUserToken(session uint32, token *Token) (err error) {
4708
	r1, _, e1 := syscall.SyscallN(procWTSQueryUserToken.Addr(), uintptr(session), uintptr(unsafe.Pointer(token)))
4709
	if r1 == 0 {
4710
		err = errnoErr(e1)
4711
	}
4712
	return
4713
}
4714

4715