1
2
3 package windows
4
5 import (
6 "syscall"
7 "unsafe"
8 )
9
10 var _ unsafe.Pointer
11
12
13
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
24
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
33
34
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
View as plain text