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 procFreeMibTable = modiphlpapi.NewProc("FreeMibTable")
186 procGetAdaptersAddresses = modiphlpapi.NewProc("GetAdaptersAddresses")
187 procGetAdaptersInfo = modiphlpapi.NewProc("GetAdaptersInfo")
188 procGetBestInterfaceEx = modiphlpapi.NewProc("GetBestInterfaceEx")
189 procGetIfEntry = modiphlpapi.NewProc("GetIfEntry")
190 procGetIfEntry2Ex = modiphlpapi.NewProc("GetIfEntry2Ex")
191 procGetIpForwardEntry2 = modiphlpapi.NewProc("GetIpForwardEntry2")
192 procGetIpForwardTable2 = modiphlpapi.NewProc("GetIpForwardTable2")
193 procGetUnicastIpAddressEntry = modiphlpapi.NewProc("GetUnicastIpAddressEntry")
194 procNotifyIpInterfaceChange = modiphlpapi.NewProc("NotifyIpInterfaceChange")
195 procNotifyRouteChange2 = modiphlpapi.NewProc("NotifyRouteChange2")
196 procNotifyUnicastIpAddressChange = modiphlpapi.NewProc("NotifyUnicastIpAddressChange")
197 procAddDllDirectory = modkernel32.NewProc("AddDllDirectory")
198 procAssignProcessToJobObject = modkernel32.NewProc("AssignProcessToJobObject")
199 procCancelIo = modkernel32.NewProc("CancelIo")
200 procCancelIoEx = modkernel32.NewProc("CancelIoEx")
201 procClearCommBreak = modkernel32.NewProc("ClearCommBreak")
202 procClearCommError = modkernel32.NewProc("ClearCommError")
203 procCloseHandle = modkernel32.NewProc("CloseHandle")
204 procClosePseudoConsole = modkernel32.NewProc("ClosePseudoConsole")
205 procConnectNamedPipe = modkernel32.NewProc("ConnectNamedPipe")
206 procCreateDirectoryW = modkernel32.NewProc("CreateDirectoryW")
207 procCreateEventExW = modkernel32.NewProc("CreateEventExW")
208 procCreateEventW = modkernel32.NewProc("CreateEventW")
209 procCreateFileMappingW = modkernel32.NewProc("CreateFileMappingW")
210 procCreateFileW = modkernel32.NewProc("CreateFileW")
211 procCreateHardLinkW = modkernel32.NewProc("CreateHardLinkW")
212 procCreateIoCompletionPort = modkernel32.NewProc("CreateIoCompletionPort")
213 procCreateJobObjectW = modkernel32.NewProc("CreateJobObjectW")
214 procCreateMutexExW = modkernel32.NewProc("CreateMutexExW")
215 procCreateMutexW = modkernel32.NewProc("CreateMutexW")
216 procCreateNamedPipeW = modkernel32.NewProc("CreateNamedPipeW")
217 procCreatePipe = modkernel32.NewProc("CreatePipe")
218 procCreateProcessW = modkernel32.NewProc("CreateProcessW")
219 procCreatePseudoConsole = modkernel32.NewProc("CreatePseudoConsole")
220 procCreateSymbolicLinkW = modkernel32.NewProc("CreateSymbolicLinkW")
221 procCreateToolhelp32Snapshot = modkernel32.NewProc("CreateToolhelp32Snapshot")
222 procDefineDosDeviceW = modkernel32.NewProc("DefineDosDeviceW")
223 procDeleteFileW = modkernel32.NewProc("DeleteFileW")
224 procDeleteProcThreadAttributeList = modkernel32.NewProc("DeleteProcThreadAttributeList")
225 procDeleteVolumeMountPointW = modkernel32.NewProc("DeleteVolumeMountPointW")
226 procDeviceIoControl = modkernel32.NewProc("DeviceIoControl")
227 procDisconnectNamedPipe = modkernel32.NewProc("DisconnectNamedPipe")
228 procDuplicateHandle = modkernel32.NewProc("DuplicateHandle")
229 procEscapeCommFunction = modkernel32.NewProc("EscapeCommFunction")
230 procExitProcess = modkernel32.NewProc("ExitProcess")
231 procExpandEnvironmentStringsW = modkernel32.NewProc("ExpandEnvironmentStringsW")
232 procFindClose = modkernel32.NewProc("FindClose")
233 procFindCloseChangeNotification = modkernel32.NewProc("FindCloseChangeNotification")
234 procFindFirstChangeNotificationW = modkernel32.NewProc("FindFirstChangeNotificationW")
235 procFindFirstFileW = modkernel32.NewProc("FindFirstFileW")
236 procFindFirstVolumeMountPointW = modkernel32.NewProc("FindFirstVolumeMountPointW")
237 procFindFirstVolumeW = modkernel32.NewProc("FindFirstVolumeW")
238 procFindNextChangeNotification = modkernel32.NewProc("FindNextChangeNotification")
239 procFindNextFileW = modkernel32.NewProc("FindNextFileW")
240 procFindNextVolumeMountPointW = modkernel32.NewProc("FindNextVolumeMountPointW")
241 procFindNextVolumeW = modkernel32.NewProc("FindNextVolumeW")
242 procFindResourceW = modkernel32.NewProc("FindResourceW")
243 procFindVolumeClose = modkernel32.NewProc("FindVolumeClose")
244 procFindVolumeMountPointClose = modkernel32.NewProc("FindVolumeMountPointClose")
245 procFlushConsoleInputBuffer = modkernel32.NewProc("FlushConsoleInputBuffer")
246 procFlushFileBuffers = modkernel32.NewProc("FlushFileBuffers")
247 procFlushViewOfFile = modkernel32.NewProc("FlushViewOfFile")
248 procFormatMessageW = modkernel32.NewProc("FormatMessageW")
249 procFreeEnvironmentStringsW = modkernel32.NewProc("FreeEnvironmentStringsW")
250 procFreeLibrary = modkernel32.NewProc("FreeLibrary")
251 procGenerateConsoleCtrlEvent = modkernel32.NewProc("GenerateConsoleCtrlEvent")
252 procGetACP = modkernel32.NewProc("GetACP")
253 procGetActiveProcessorCount = modkernel32.NewProc("GetActiveProcessorCount")
254 procGetCommModemStatus = modkernel32.NewProc("GetCommModemStatus")
255 procGetCommState = modkernel32.NewProc("GetCommState")
256 procGetCommTimeouts = modkernel32.NewProc("GetCommTimeouts")
257 procGetCommandLineW = modkernel32.NewProc("GetCommandLineW")
258 procGetComputerNameExW = modkernel32.NewProc("GetComputerNameExW")
259 procGetComputerNameW = modkernel32.NewProc("GetComputerNameW")
260 procGetConsoleCP = modkernel32.NewProc("GetConsoleCP")
261 procGetConsoleMode = modkernel32.NewProc("GetConsoleMode")
262 procGetConsoleOutputCP = modkernel32.NewProc("GetConsoleOutputCP")
263 procGetConsoleScreenBufferInfo = modkernel32.NewProc("GetConsoleScreenBufferInfo")
264 procGetCurrentDirectoryW = modkernel32.NewProc("GetCurrentDirectoryW")
265 procGetCurrentProcessId = modkernel32.NewProc("GetCurrentProcessId")
266 procGetCurrentThreadId = modkernel32.NewProc("GetCurrentThreadId")
267 procGetDiskFreeSpaceExW = modkernel32.NewProc("GetDiskFreeSpaceExW")
268 procGetDriveTypeW = modkernel32.NewProc("GetDriveTypeW")
269 procGetEnvironmentStringsW = modkernel32.NewProc("GetEnvironmentStringsW")
270 procGetEnvironmentVariableW = modkernel32.NewProc("GetEnvironmentVariableW")
271 procGetExitCodeProcess = modkernel32.NewProc("GetExitCodeProcess")
272 procGetFileAttributesExW = modkernel32.NewProc("GetFileAttributesExW")
273 procGetFileAttributesW = modkernel32.NewProc("GetFileAttributesW")
274 procGetFileInformationByHandle = modkernel32.NewProc("GetFileInformationByHandle")
275 procGetFileInformationByHandleEx = modkernel32.NewProc("GetFileInformationByHandleEx")
276 procGetFileTime = modkernel32.NewProc("GetFileTime")
277 procGetFileType = modkernel32.NewProc("GetFileType")
278 procGetFinalPathNameByHandleW = modkernel32.NewProc("GetFinalPathNameByHandleW")
279 procGetFullPathNameW = modkernel32.NewProc("GetFullPathNameW")
280 procGetLargePageMinimum = modkernel32.NewProc("GetLargePageMinimum")
281 procGetLastError = modkernel32.NewProc("GetLastError")
282 procGetLogicalDriveStringsW = modkernel32.NewProc("GetLogicalDriveStringsW")
283 procGetLogicalDrives = modkernel32.NewProc("GetLogicalDrives")
284 procGetLongPathNameW = modkernel32.NewProc("GetLongPathNameW")
285 procGetMaximumProcessorCount = modkernel32.NewProc("GetMaximumProcessorCount")
286 procGetModuleFileNameW = modkernel32.NewProc("GetModuleFileNameW")
287 procGetModuleHandleExW = modkernel32.NewProc("GetModuleHandleExW")
288 procGetNamedPipeClientProcessId = modkernel32.NewProc("GetNamedPipeClientProcessId")
289 procGetNamedPipeHandleStateW = modkernel32.NewProc("GetNamedPipeHandleStateW")
290 procGetNamedPipeInfo = modkernel32.NewProc("GetNamedPipeInfo")
291 procGetNamedPipeServerProcessId = modkernel32.NewProc("GetNamedPipeServerProcessId")
292 procGetNumberOfConsoleInputEvents = modkernel32.NewProc("GetNumberOfConsoleInputEvents")
293 procGetOverlappedResult = modkernel32.NewProc("GetOverlappedResult")
294 procGetPriorityClass = modkernel32.NewProc("GetPriorityClass")
295 procGetProcAddress = modkernel32.NewProc("GetProcAddress")
296 procGetProcessId = modkernel32.NewProc("GetProcessId")
297 procGetProcessPreferredUILanguages = modkernel32.NewProc("GetProcessPreferredUILanguages")
298 procGetProcessShutdownParameters = modkernel32.NewProc("GetProcessShutdownParameters")
299 procGetProcessTimes = modkernel32.NewProc("GetProcessTimes")
300 procGetProcessWorkingSetSizeEx = modkernel32.NewProc("GetProcessWorkingSetSizeEx")
301 procGetQueuedCompletionStatus = modkernel32.NewProc("GetQueuedCompletionStatus")
302 procGetShortPathNameW = modkernel32.NewProc("GetShortPathNameW")
303 procGetStartupInfoW = modkernel32.NewProc("GetStartupInfoW")
304 procGetStdHandle = modkernel32.NewProc("GetStdHandle")
305 procGetSystemDirectoryW = modkernel32.NewProc("GetSystemDirectoryW")
306 procGetSystemPreferredUILanguages = modkernel32.NewProc("GetSystemPreferredUILanguages")
307 procGetSystemTimeAsFileTime = modkernel32.NewProc("GetSystemTimeAsFileTime")
308 procGetSystemTimePreciseAsFileTime = modkernel32.NewProc("GetSystemTimePreciseAsFileTime")
309 procGetSystemWindowsDirectoryW = modkernel32.NewProc("GetSystemWindowsDirectoryW")
310 procGetTempPathW = modkernel32.NewProc("GetTempPathW")
311 procGetThreadPreferredUILanguages = modkernel32.NewProc("GetThreadPreferredUILanguages")
312 procGetTickCount64 = modkernel32.NewProc("GetTickCount64")
313 procGetTimeZoneInformation = modkernel32.NewProc("GetTimeZoneInformation")
314 procGetUserPreferredUILanguages = modkernel32.NewProc("GetUserPreferredUILanguages")
315 procGetVersion = modkernel32.NewProc("GetVersion")
316 procGetVolumeInformationByHandleW = modkernel32.NewProc("GetVolumeInformationByHandleW")
317 procGetVolumeInformationW = modkernel32.NewProc("GetVolumeInformationW")
318 procGetVolumeNameForVolumeMountPointW = modkernel32.NewProc("GetVolumeNameForVolumeMountPointW")
319 procGetVolumePathNameW = modkernel32.NewProc("GetVolumePathNameW")
320 procGetVolumePathNamesForVolumeNameW = modkernel32.NewProc("GetVolumePathNamesForVolumeNameW")
321 procGetWindowsDirectoryW = modkernel32.NewProc("GetWindowsDirectoryW")
322 procInitializeProcThreadAttributeList = modkernel32.NewProc("InitializeProcThreadAttributeList")
323 procIsWow64Process = modkernel32.NewProc("IsWow64Process")
324 procIsWow64Process2 = modkernel32.NewProc("IsWow64Process2")
325 procLoadLibraryExW = modkernel32.NewProc("LoadLibraryExW")
326 procLoadLibraryW = modkernel32.NewProc("LoadLibraryW")
327 procLoadResource = modkernel32.NewProc("LoadResource")
328 procLocalAlloc = modkernel32.NewProc("LocalAlloc")
329 procLocalFree = modkernel32.NewProc("LocalFree")
330 procLockFileEx = modkernel32.NewProc("LockFileEx")
331 procLockResource = modkernel32.NewProc("LockResource")
332 procMapViewOfFile = modkernel32.NewProc("MapViewOfFile")
333 procModule32FirstW = modkernel32.NewProc("Module32FirstW")
334 procModule32NextW = modkernel32.NewProc("Module32NextW")
335 procMoveFileExW = modkernel32.NewProc("MoveFileExW")
336 procMoveFileW = modkernel32.NewProc("MoveFileW")
337 procMultiByteToWideChar = modkernel32.NewProc("MultiByteToWideChar")
338 procOpenEventW = modkernel32.NewProc("OpenEventW")
339 procOpenMutexW = modkernel32.NewProc("OpenMutexW")
340 procOpenProcess = modkernel32.NewProc("OpenProcess")
341 procOpenThread = modkernel32.NewProc("OpenThread")
342 procPostQueuedCompletionStatus = modkernel32.NewProc("PostQueuedCompletionStatus")
343 procProcess32FirstW = modkernel32.NewProc("Process32FirstW")
344 procProcess32NextW = modkernel32.NewProc("Process32NextW")
345 procProcessIdToSessionId = modkernel32.NewProc("ProcessIdToSessionId")
346 procPulseEvent = modkernel32.NewProc("PulseEvent")
347 procPurgeComm = modkernel32.NewProc("PurgeComm")
348 procQueryDosDeviceW = modkernel32.NewProc("QueryDosDeviceW")
349 procQueryFullProcessImageNameW = modkernel32.NewProc("QueryFullProcessImageNameW")
350 procQueryInformationJobObject = modkernel32.NewProc("QueryInformationJobObject")
351 procReadConsoleW = modkernel32.NewProc("ReadConsoleW")
352 procReadDirectoryChangesW = modkernel32.NewProc("ReadDirectoryChangesW")
353 procReadFile = modkernel32.NewProc("ReadFile")
354 procReadProcessMemory = modkernel32.NewProc("ReadProcessMemory")
355 procReleaseMutex = modkernel32.NewProc("ReleaseMutex")
356 procRemoveDirectoryW = modkernel32.NewProc("RemoveDirectoryW")
357 procRemoveDllDirectory = modkernel32.NewProc("RemoveDllDirectory")
358 procResetEvent = modkernel32.NewProc("ResetEvent")
359 procResizePseudoConsole = modkernel32.NewProc("ResizePseudoConsole")
360 procResumeThread = modkernel32.NewProc("ResumeThread")
361 procSetCommBreak = modkernel32.NewProc("SetCommBreak")
362 procSetCommMask = modkernel32.NewProc("SetCommMask")
363 procSetCommState = modkernel32.NewProc("SetCommState")
364 procSetCommTimeouts = modkernel32.NewProc("SetCommTimeouts")
365 procSetConsoleCP = modkernel32.NewProc("SetConsoleCP")
366 procSetConsoleCursorPosition = modkernel32.NewProc("SetConsoleCursorPosition")
367 procSetConsoleMode = modkernel32.NewProc("SetConsoleMode")
368 procSetConsoleOutputCP = modkernel32.NewProc("SetConsoleOutputCP")
369 procSetCurrentDirectoryW = modkernel32.NewProc("SetCurrentDirectoryW")
370 procSetDefaultDllDirectories = modkernel32.NewProc("SetDefaultDllDirectories")
371 procSetDllDirectoryW = modkernel32.NewProc("SetDllDirectoryW")
372 procSetEndOfFile = modkernel32.NewProc("SetEndOfFile")
373 procSetEnvironmentVariableW = modkernel32.NewProc("SetEnvironmentVariableW")
374 procSetErrorMode = modkernel32.NewProc("SetErrorMode")
375 procSetEvent = modkernel32.NewProc("SetEvent")
376 procSetFileAttributesW = modkernel32.NewProc("SetFileAttributesW")
377 procSetFileCompletionNotificationModes = modkernel32.NewProc("SetFileCompletionNotificationModes")
378 procSetFileInformationByHandle = modkernel32.NewProc("SetFileInformationByHandle")
379 procSetFilePointer = modkernel32.NewProc("SetFilePointer")
380 procSetFileTime = modkernel32.NewProc("SetFileTime")
381 procSetFileValidData = modkernel32.NewProc("SetFileValidData")
382 procSetHandleInformation = modkernel32.NewProc("SetHandleInformation")
383 procSetInformationJobObject = modkernel32.NewProc("SetInformationJobObject")
384 procSetNamedPipeHandleState = modkernel32.NewProc("SetNamedPipeHandleState")
385 procSetPriorityClass = modkernel32.NewProc("SetPriorityClass")
386 procSetProcessPriorityBoost = modkernel32.NewProc("SetProcessPriorityBoost")
387 procSetProcessShutdownParameters = modkernel32.NewProc("SetProcessShutdownParameters")
388 procSetProcessWorkingSetSizeEx = modkernel32.NewProc("SetProcessWorkingSetSizeEx")
389 procSetStdHandle = modkernel32.NewProc("SetStdHandle")
390 procSetVolumeLabelW = modkernel32.NewProc("SetVolumeLabelW")
391 procSetVolumeMountPointW = modkernel32.NewProc("SetVolumeMountPointW")
392 procSetupComm = modkernel32.NewProc("SetupComm")
393 procSizeofResource = modkernel32.NewProc("SizeofResource")
394 procSleepEx = modkernel32.NewProc("SleepEx")
395 procTerminateJobObject = modkernel32.NewProc("TerminateJobObject")
396 procTerminateProcess = modkernel32.NewProc("TerminateProcess")
397 procThread32First = modkernel32.NewProc("Thread32First")
398 procThread32Next = modkernel32.NewProc("Thread32Next")
399 procUnlockFileEx = modkernel32.NewProc("UnlockFileEx")
400 procUnmapViewOfFile = modkernel32.NewProc("UnmapViewOfFile")
401 procUpdateProcThreadAttribute = modkernel32.NewProc("UpdateProcThreadAttribute")
402 procVirtualAlloc = modkernel32.NewProc("VirtualAlloc")
403 procVirtualFree = modkernel32.NewProc("VirtualFree")
404 procVirtualLock = modkernel32.NewProc("VirtualLock")
405 procVirtualProtect = modkernel32.NewProc("VirtualProtect")
406 procVirtualProtectEx = modkernel32.NewProc("VirtualProtectEx")
407 procVirtualQuery = modkernel32.NewProc("VirtualQuery")
408 procVirtualQueryEx = modkernel32.NewProc("VirtualQueryEx")
409 procVirtualUnlock = modkernel32.NewProc("VirtualUnlock")
410 procWTSGetActiveConsoleSessionId = modkernel32.NewProc("WTSGetActiveConsoleSessionId")
411 procWaitCommEvent = modkernel32.NewProc("WaitCommEvent")
412 procWaitForMultipleObjects = modkernel32.NewProc("WaitForMultipleObjects")
413 procWaitForSingleObject = modkernel32.NewProc("WaitForSingleObject")
414 procWriteConsoleW = modkernel32.NewProc("WriteConsoleW")
415 procWriteFile = modkernel32.NewProc("WriteFile")
416 procWriteProcessMemory = modkernel32.NewProc("WriteProcessMemory")
417 procAcceptEx = modmswsock.NewProc("AcceptEx")
418 procGetAcceptExSockaddrs = modmswsock.NewProc("GetAcceptExSockaddrs")
419 procTransmitFile = modmswsock.NewProc("TransmitFile")
420 procNetApiBufferFree = modnetapi32.NewProc("NetApiBufferFree")
421 procNetGetJoinInformation = modnetapi32.NewProc("NetGetJoinInformation")
422 procNetUserEnum = modnetapi32.NewProc("NetUserEnum")
423 procNetUserGetInfo = modnetapi32.NewProc("NetUserGetInfo")
424 procNtCreateFile = modntdll.NewProc("NtCreateFile")
425 procNtCreateNamedPipeFile = modntdll.NewProc("NtCreateNamedPipeFile")
426 procNtQueryInformationProcess = modntdll.NewProc("NtQueryInformationProcess")
427 procNtQuerySystemInformation = modntdll.NewProc("NtQuerySystemInformation")
428 procNtSetInformationFile = modntdll.NewProc("NtSetInformationFile")
429 procNtSetInformationProcess = modntdll.NewProc("NtSetInformationProcess")
430 procNtSetSystemInformation = modntdll.NewProc("NtSetSystemInformation")
431 procRtlAddFunctionTable = modntdll.NewProc("RtlAddFunctionTable")
432 procRtlDefaultNpAcl = modntdll.NewProc("RtlDefaultNpAcl")
433 procRtlDeleteFunctionTable = modntdll.NewProc("RtlDeleteFunctionTable")
434 procRtlDosPathNameToNtPathName_U_WithStatus = modntdll.NewProc("RtlDosPathNameToNtPathName_U_WithStatus")
435 procRtlDosPathNameToRelativeNtPathName_U_WithStatus = modntdll.NewProc("RtlDosPathNameToRelativeNtPathName_U_WithStatus")
436 procRtlGetCurrentPeb = modntdll.NewProc("RtlGetCurrentPeb")
437 procRtlGetNtVersionNumbers = modntdll.NewProc("RtlGetNtVersionNumbers")
438 procRtlGetVersion = modntdll.NewProc("RtlGetVersion")
439 procRtlInitString = modntdll.NewProc("RtlInitString")
440 procRtlInitUnicodeString = modntdll.NewProc("RtlInitUnicodeString")
441 procRtlNtStatusToDosErrorNoTeb = modntdll.NewProc("RtlNtStatusToDosErrorNoTeb")
442 procCLSIDFromString = modole32.NewProc("CLSIDFromString")
443 procCoCreateGuid = modole32.NewProc("CoCreateGuid")
444 procCoGetObject = modole32.NewProc("CoGetObject")
445 procCoInitializeEx = modole32.NewProc("CoInitializeEx")
446 procCoTaskMemFree = modole32.NewProc("CoTaskMemFree")
447 procCoUninitialize = modole32.NewProc("CoUninitialize")
448 procStringFromGUID2 = modole32.NewProc("StringFromGUID2")
449 procEnumProcessModules = modpsapi.NewProc("EnumProcessModules")
450 procEnumProcessModulesEx = modpsapi.NewProc("EnumProcessModulesEx")
451 procEnumProcesses = modpsapi.NewProc("EnumProcesses")
452 procGetModuleBaseNameW = modpsapi.NewProc("GetModuleBaseNameW")
453 procGetModuleFileNameExW = modpsapi.NewProc("GetModuleFileNameExW")
454 procGetModuleInformation = modpsapi.NewProc("GetModuleInformation")
455 procQueryWorkingSetEx = modpsapi.NewProc("QueryWorkingSetEx")
456 procSubscribeServiceChangeNotifications = modsechost.NewProc("SubscribeServiceChangeNotifications")
457 procUnsubscribeServiceChangeNotifications = modsechost.NewProc("UnsubscribeServiceChangeNotifications")
458 procGetUserNameExW = modsecur32.NewProc("GetUserNameExW")
459 procTranslateNameW = modsecur32.NewProc("TranslateNameW")
460 procSetupDiBuildDriverInfoList = modsetupapi.NewProc("SetupDiBuildDriverInfoList")
461 procSetupDiCallClassInstaller = modsetupapi.NewProc("SetupDiCallClassInstaller")
462 procSetupDiCancelDriverInfoSearch = modsetupapi.NewProc("SetupDiCancelDriverInfoSearch")
463 procSetupDiClassGuidsFromNameExW = modsetupapi.NewProc("SetupDiClassGuidsFromNameExW")
464 procSetupDiClassNameFromGuidExW = modsetupapi.NewProc("SetupDiClassNameFromGuidExW")
465 procSetupDiCreateDeviceInfoListExW = modsetupapi.NewProc("SetupDiCreateDeviceInfoListExW")
466 procSetupDiCreateDeviceInfoW = modsetupapi.NewProc("SetupDiCreateDeviceInfoW")
467 procSetupDiDestroyDeviceInfoList = modsetupapi.NewProc("SetupDiDestroyDeviceInfoList")
468 procSetupDiDestroyDriverInfoList = modsetupapi.NewProc("SetupDiDestroyDriverInfoList")
469 procSetupDiEnumDeviceInfo = modsetupapi.NewProc("SetupDiEnumDeviceInfo")
470 procSetupDiEnumDriverInfoW = modsetupapi.NewProc("SetupDiEnumDriverInfoW")
471 procSetupDiGetClassDevsExW = modsetupapi.NewProc("SetupDiGetClassDevsExW")
472 procSetupDiGetClassInstallParamsW = modsetupapi.NewProc("SetupDiGetClassInstallParamsW")
473 procSetupDiGetDeviceInfoListDetailW = modsetupapi.NewProc("SetupDiGetDeviceInfoListDetailW")
474 procSetupDiGetDeviceInstallParamsW = modsetupapi.NewProc("SetupDiGetDeviceInstallParamsW")
475 procSetupDiGetDeviceInstanceIdW = modsetupapi.NewProc("SetupDiGetDeviceInstanceIdW")
476 procSetupDiGetDevicePropertyW = modsetupapi.NewProc("SetupDiGetDevicePropertyW")
477 procSetupDiGetDeviceRegistryPropertyW = modsetupapi.NewProc("SetupDiGetDeviceRegistryPropertyW")
478 procSetupDiGetDriverInfoDetailW = modsetupapi.NewProc("SetupDiGetDriverInfoDetailW")
479 procSetupDiGetSelectedDevice = modsetupapi.NewProc("SetupDiGetSelectedDevice")
480 procSetupDiGetSelectedDriverW = modsetupapi.NewProc("SetupDiGetSelectedDriverW")
481 procSetupDiOpenDevRegKey = modsetupapi.NewProc("SetupDiOpenDevRegKey")
482 procSetupDiSetClassInstallParamsW = modsetupapi.NewProc("SetupDiSetClassInstallParamsW")
483 procSetupDiSetDeviceInstallParamsW = modsetupapi.NewProc("SetupDiSetDeviceInstallParamsW")
484 procSetupDiSetDeviceRegistryPropertyW = modsetupapi.NewProc("SetupDiSetDeviceRegistryPropertyW")
485 procSetupDiSetSelectedDevice = modsetupapi.NewProc("SetupDiSetSelectedDevice")
486 procSetupDiSetSelectedDriverW = modsetupapi.NewProc("SetupDiSetSelectedDriverW")
487 procSetupUninstallOEMInfW = modsetupapi.NewProc("SetupUninstallOEMInfW")
488 procCommandLineToArgvW = modshell32.NewProc("CommandLineToArgvW")
489 procSHGetKnownFolderPath = modshell32.NewProc("SHGetKnownFolderPath")
490 procShellExecuteW = modshell32.NewProc("ShellExecuteW")
491 procEnumChildWindows = moduser32.NewProc("EnumChildWindows")
492 procEnumWindows = moduser32.NewProc("EnumWindows")
493 procExitWindowsEx = moduser32.NewProc("ExitWindowsEx")
494 procGetClassNameW = moduser32.NewProc("GetClassNameW")
495 procGetDesktopWindow = moduser32.NewProc("GetDesktopWindow")
496 procGetForegroundWindow = moduser32.NewProc("GetForegroundWindow")
497 procGetGUIThreadInfo = moduser32.NewProc("GetGUIThreadInfo")
498 procGetKeyboardLayout = moduser32.NewProc("GetKeyboardLayout")
499 procGetShellWindow = moduser32.NewProc("GetShellWindow")
500 procGetWindowThreadProcessId = moduser32.NewProc("GetWindowThreadProcessId")
501 procIsWindow = moduser32.NewProc("IsWindow")
502 procIsWindowUnicode = moduser32.NewProc("IsWindowUnicode")
503 procIsWindowVisible = moduser32.NewProc("IsWindowVisible")
504 procLoadKeyboardLayoutW = moduser32.NewProc("LoadKeyboardLayoutW")
505 procMessageBoxW = moduser32.NewProc("MessageBoxW")
506 procToUnicodeEx = moduser32.NewProc("ToUnicodeEx")
507 procUnloadKeyboardLayout = moduser32.NewProc("UnloadKeyboardLayout")
508 procCreateEnvironmentBlock = moduserenv.NewProc("CreateEnvironmentBlock")
509 procDestroyEnvironmentBlock = moduserenv.NewProc("DestroyEnvironmentBlock")
510 procGetUserProfileDirectoryW = moduserenv.NewProc("GetUserProfileDirectoryW")
511 procGetFileVersionInfoSizeW = modversion.NewProc("GetFileVersionInfoSizeW")
512 procGetFileVersionInfoW = modversion.NewProc("GetFileVersionInfoW")
513 procVerQueryValueW = modversion.NewProc("VerQueryValueW")
514 proctimeBeginPeriod = modwinmm.NewProc("timeBeginPeriod")
515 proctimeEndPeriod = modwinmm.NewProc("timeEndPeriod")
516 procWinVerifyTrustEx = modwintrust.NewProc("WinVerifyTrustEx")
517 procFreeAddrInfoW = modws2_32.NewProc("FreeAddrInfoW")
518 procGetAddrInfoW = modws2_32.NewProc("GetAddrInfoW")
519 procWSACleanup = modws2_32.NewProc("WSACleanup")
520 procWSADuplicateSocketW = modws2_32.NewProc("WSADuplicateSocketW")
521 procWSAEnumProtocolsW = modws2_32.NewProc("WSAEnumProtocolsW")
522 procWSAGetOverlappedResult = modws2_32.NewProc("WSAGetOverlappedResult")
523 procWSAIoctl = modws2_32.NewProc("WSAIoctl")
524 procWSALookupServiceBeginW = modws2_32.NewProc("WSALookupServiceBeginW")
525 procWSALookupServiceEnd = modws2_32.NewProc("WSALookupServiceEnd")
526 procWSALookupServiceNextW = modws2_32.NewProc("WSALookupServiceNextW")
527 procWSARecv = modws2_32.NewProc("WSARecv")
528 procWSARecvFrom = modws2_32.NewProc("WSARecvFrom")
529 procWSASend = modws2_32.NewProc("WSASend")
530 procWSASendTo = modws2_32.NewProc("WSASendTo")
531 procWSASocketW = modws2_32.NewProc("WSASocketW")
532 procWSAStartup = modws2_32.NewProc("WSAStartup")
533 procbind = modws2_32.NewProc("bind")
534 procclosesocket = modws2_32.NewProc("closesocket")
535 procconnect = modws2_32.NewProc("connect")
536 procgethostbyname = modws2_32.NewProc("gethostbyname")
537 procgetpeername = modws2_32.NewProc("getpeername")
538 procgetprotobyname = modws2_32.NewProc("getprotobyname")
539 procgetservbyname = modws2_32.NewProc("getservbyname")
540 procgetsockname = modws2_32.NewProc("getsockname")
541 procgetsockopt = modws2_32.NewProc("getsockopt")
542 proclisten = modws2_32.NewProc("listen")
543 procntohs = modws2_32.NewProc("ntohs")
544 procrecvfrom = modws2_32.NewProc("recvfrom")
545 procsendto = modws2_32.NewProc("sendto")
546 procsetsockopt = modws2_32.NewProc("setsockopt")
547 procshutdown = modws2_32.NewProc("shutdown")
548 procsocket = modws2_32.NewProc("socket")
549 procWTSEnumerateSessionsW = modwtsapi32.NewProc("WTSEnumerateSessionsW")
550 procWTSFreeMemory = modwtsapi32.NewProc("WTSFreeMemory")
551 procWTSQueryUserToken = modwtsapi32.NewProc("WTSQueryUserToken")
552 )
553
554 func cm_Get_DevNode_Status(status *uint32, problemNumber *uint32, devInst DEVINST, flags uint32) (ret CONFIGRET) {
555 r0, _, _ := syscall.SyscallN(procCM_Get_DevNode_Status.Addr(), uintptr(unsafe.Pointer(status)), uintptr(unsafe.Pointer(problemNumber)), uintptr(devInst), uintptr(flags))
556 ret = CONFIGRET(r0)
557 return
558 }
559
560 func cm_Get_Device_Interface_List(interfaceClass *GUID, deviceID *uint16, buffer *uint16, bufferLen uint32, flags uint32) (ret CONFIGRET) {
561 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))
562 ret = CONFIGRET(r0)
563 return
564 }
565
566 func cm_Get_Device_Interface_List_Size(len *uint32, interfaceClass *GUID, deviceID *uint16, flags uint32) (ret CONFIGRET) {
567 r0, _, _ := syscall.SyscallN(procCM_Get_Device_Interface_List_SizeW.Addr(), uintptr(unsafe.Pointer(len)), uintptr(unsafe.Pointer(interfaceClass)), uintptr(unsafe.Pointer(deviceID)), uintptr(flags))
568 ret = CONFIGRET(r0)
569 return
570 }
571
572 func cm_MapCrToWin32Err(configRet CONFIGRET, defaultWin32Error Errno) (ret Errno) {
573 r0, _, _ := syscall.SyscallN(procCM_MapCrToWin32Err.Addr(), uintptr(configRet), uintptr(defaultWin32Error))
574 ret = Errno(r0)
575 return
576 }
577
578 func AdjustTokenGroups(token Token, resetToDefault bool, newstate *Tokengroups, buflen uint32, prevstate *Tokengroups, returnlen *uint32) (err error) {
579 var _p0 uint32
580 if resetToDefault {
581 _p0 = 1
582 }
583 r1, _, e1 := syscall.SyscallN(procAdjustTokenGroups.Addr(), uintptr(token), uintptr(_p0), uintptr(unsafe.Pointer(newstate)), uintptr(buflen), uintptr(unsafe.Pointer(prevstate)), uintptr(unsafe.Pointer(returnlen)))
584 if r1 == 0 {
585 err = errnoErr(e1)
586 }
587 return
588 }
589
590 func AdjustTokenPrivileges(token Token, disableAllPrivileges bool, newstate *Tokenprivileges, buflen uint32, prevstate *Tokenprivileges, returnlen *uint32) (err error) {
591 var _p0 uint32
592 if disableAllPrivileges {
593 _p0 = 1
594 }
595 r1, _, e1 := syscall.SyscallN(procAdjustTokenPrivileges.Addr(), uintptr(token), uintptr(_p0), uintptr(unsafe.Pointer(newstate)), uintptr(buflen), uintptr(unsafe.Pointer(prevstate)), uintptr(unsafe.Pointer(returnlen)))
596 if r1 == 0 {
597 err = errnoErr(e1)
598 }
599 return
600 }
601
602 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) {
603 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)))
604 if r1 == 0 {
605 err = errnoErr(e1)
606 }
607 return
608 }
609
610 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) {
611 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)))
612 if r0 != 0 {
613 ret = syscall.Errno(r0)
614 }
615 return
616 }
617
618 func ChangeServiceConfig2(service Handle, infoLevel uint32, info *byte) (err error) {
619 r1, _, e1 := syscall.SyscallN(procChangeServiceConfig2W.Addr(), uintptr(service), uintptr(infoLevel), uintptr(unsafe.Pointer(info)))
620 if r1 == 0 {
621 err = errnoErr(e1)
622 }
623 return
624 }
625
626 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) {
627 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)))
628 if r1 == 0 {
629 err = errnoErr(e1)
630 }
631 return
632 }
633
634 func checkTokenMembership(tokenHandle Token, sidToCheck *SID, isMember *int32) (err error) {
635 r1, _, e1 := syscall.SyscallN(procCheckTokenMembership.Addr(), uintptr(tokenHandle), uintptr(unsafe.Pointer(sidToCheck)), uintptr(unsafe.Pointer(isMember)))
636 if r1 == 0 {
637 err = errnoErr(e1)
638 }
639 return
640 }
641
642 func CloseServiceHandle(handle Handle) (err error) {
643 r1, _, e1 := syscall.SyscallN(procCloseServiceHandle.Addr(), uintptr(handle))
644 if r1 == 0 {
645 err = errnoErr(e1)
646 }
647 return
648 }
649
650 func ControlService(service Handle, control uint32, status *SERVICE_STATUS) (err error) {
651 r1, _, e1 := syscall.SyscallN(procControlService.Addr(), uintptr(service), uintptr(control), uintptr(unsafe.Pointer(status)))
652 if r1 == 0 {
653 err = errnoErr(e1)
654 }
655 return
656 }
657
658 func convertSecurityDescriptorToStringSecurityDescriptor(sd *SECURITY_DESCRIPTOR, revision uint32, securityInformation SECURITY_INFORMATION, str **uint16, strLen *uint32) (err error) {
659 r1, _, e1 := syscall.SyscallN(procConvertSecurityDescriptorToStringSecurityDescriptorW.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(revision), uintptr(securityInformation), uintptr(unsafe.Pointer(str)), uintptr(unsafe.Pointer(strLen)))
660 if r1 == 0 {
661 err = errnoErr(e1)
662 }
663 return
664 }
665
666 func ConvertSidToStringSid(sid *SID, stringSid **uint16) (err error) {
667 r1, _, e1 := syscall.SyscallN(procConvertSidToStringSidW.Addr(), uintptr(unsafe.Pointer(sid)), uintptr(unsafe.Pointer(stringSid)))
668 if r1 == 0 {
669 err = errnoErr(e1)
670 }
671 return
672 }
673
674 func convertStringSecurityDescriptorToSecurityDescriptor(str string, revision uint32, sd **SECURITY_DESCRIPTOR, size *uint32) (err error) {
675 var _p0 *uint16
676 _p0, err = syscall.UTF16PtrFromString(str)
677 if err != nil {
678 return
679 }
680 return _convertStringSecurityDescriptorToSecurityDescriptor(_p0, revision, sd, size)
681 }
682
683 func _convertStringSecurityDescriptorToSecurityDescriptor(str *uint16, revision uint32, sd **SECURITY_DESCRIPTOR, size *uint32) (err error) {
684 r1, _, e1 := syscall.SyscallN(procConvertStringSecurityDescriptorToSecurityDescriptorW.Addr(), uintptr(unsafe.Pointer(str)), uintptr(revision), uintptr(unsafe.Pointer(sd)), uintptr(unsafe.Pointer(size)))
685 if r1 == 0 {
686 err = errnoErr(e1)
687 }
688 return
689 }
690
691 func ConvertStringSidToSid(stringSid *uint16, sid **SID) (err error) {
692 r1, _, e1 := syscall.SyscallN(procConvertStringSidToSidW.Addr(), uintptr(unsafe.Pointer(stringSid)), uintptr(unsafe.Pointer(sid)))
693 if r1 == 0 {
694 err = errnoErr(e1)
695 }
696 return
697 }
698
699 func CopySid(destSidLen uint32, destSid *SID, srcSid *SID) (err error) {
700 r1, _, e1 := syscall.SyscallN(procCopySid.Addr(), uintptr(destSidLen), uintptr(unsafe.Pointer(destSid)), uintptr(unsafe.Pointer(srcSid)))
701 if r1 == 0 {
702 err = errnoErr(e1)
703 }
704 return
705 }
706
707 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) {
708 var _p0 uint32
709 if inheritHandles {
710 _p0 = 1
711 }
712 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)))
713 if r1 == 0 {
714 err = errnoErr(e1)
715 }
716 return
717 }
718
719 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) {
720 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)))
721 handle = Handle(r0)
722 if handle == 0 {
723 err = errnoErr(e1)
724 }
725 return
726 }
727
728 func createWellKnownSid(sidType WELL_KNOWN_SID_TYPE, domainSid *SID, sid *SID, sizeSid *uint32) (err error) {
729 r1, _, e1 := syscall.SyscallN(procCreateWellKnownSid.Addr(), uintptr(sidType), uintptr(unsafe.Pointer(domainSid)), uintptr(unsafe.Pointer(sid)), uintptr(unsafe.Pointer(sizeSid)))
730 if r1 == 0 {
731 err = errnoErr(e1)
732 }
733 return
734 }
735
736 func CryptAcquireContext(provhandle *Handle, container *uint16, provider *uint16, provtype uint32, flags uint32) (err error) {
737 r1, _, e1 := syscall.SyscallN(procCryptAcquireContextW.Addr(), uintptr(unsafe.Pointer(provhandle)), uintptr(unsafe.Pointer(container)), uintptr(unsafe.Pointer(provider)), uintptr(provtype), uintptr(flags))
738 if r1 == 0 {
739 err = errnoErr(e1)
740 }
741 return
742 }
743
744 func CryptGenRandom(provhandle Handle, buflen uint32, buf *byte) (err error) {
745 r1, _, e1 := syscall.SyscallN(procCryptGenRandom.Addr(), uintptr(provhandle), uintptr(buflen), uintptr(unsafe.Pointer(buf)))
746 if r1 == 0 {
747 err = errnoErr(e1)
748 }
749 return
750 }
751
752 func CryptReleaseContext(provhandle Handle, flags uint32) (err error) {
753 r1, _, e1 := syscall.SyscallN(procCryptReleaseContext.Addr(), uintptr(provhandle), uintptr(flags))
754 if r1 == 0 {
755 err = errnoErr(e1)
756 }
757 return
758 }
759
760 func DeleteService(service Handle) (err error) {
761 r1, _, e1 := syscall.SyscallN(procDeleteService.Addr(), uintptr(service))
762 if r1 == 0 {
763 err = errnoErr(e1)
764 }
765 return
766 }
767
768 func DeregisterEventSource(handle Handle) (err error) {
769 r1, _, e1 := syscall.SyscallN(procDeregisterEventSource.Addr(), uintptr(handle))
770 if r1 == 0 {
771 err = errnoErr(e1)
772 }
773 return
774 }
775
776 func DuplicateTokenEx(existingToken Token, desiredAccess uint32, tokenAttributes *SecurityAttributes, impersonationLevel uint32, tokenType uint32, newToken *Token) (err error) {
777 r1, _, e1 := syscall.SyscallN(procDuplicateTokenEx.Addr(), uintptr(existingToken), uintptr(desiredAccess), uintptr(unsafe.Pointer(tokenAttributes)), uintptr(impersonationLevel), uintptr(tokenType), uintptr(unsafe.Pointer(newToken)))
778 if r1 == 0 {
779 err = errnoErr(e1)
780 }
781 return
782 }
783
784 func EnumDependentServices(service Handle, activityState uint32, services *ENUM_SERVICE_STATUS, buffSize uint32, bytesNeeded *uint32, servicesReturned *uint32) (err error) {
785 r1, _, e1 := syscall.SyscallN(procEnumDependentServicesW.Addr(), uintptr(service), uintptr(activityState), uintptr(unsafe.Pointer(services)), uintptr(buffSize), uintptr(unsafe.Pointer(bytesNeeded)), uintptr(unsafe.Pointer(servicesReturned)))
786 if r1 == 0 {
787 err = errnoErr(e1)
788 }
789 return
790 }
791
792 func EnumServicesStatusEx(mgr Handle, infoLevel uint32, serviceType uint32, serviceState uint32, services *byte, bufSize uint32, bytesNeeded *uint32, servicesReturned *uint32, resumeHandle *uint32, groupName *uint16) (err error) {
793 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)))
794 if r1 == 0 {
795 err = errnoErr(e1)
796 }
797 return
798 }
799
800 func EqualSid(sid1 *SID, sid2 *SID) (isEqual bool) {
801 r0, _, _ := syscall.SyscallN(procEqualSid.Addr(), uintptr(unsafe.Pointer(sid1)), uintptr(unsafe.Pointer(sid2)))
802 isEqual = r0 != 0
803 return
804 }
805
806 func FreeSid(sid *SID) (err error) {
807 r1, _, e1 := syscall.SyscallN(procFreeSid.Addr(), uintptr(unsafe.Pointer(sid)))
808 if r1 != 0 {
809 err = errnoErr(e1)
810 }
811 return
812 }
813
814 func GetAce(acl *ACL, aceIndex uint32, pAce **ACCESS_ALLOWED_ACE) (err error) {
815 r1, _, e1 := syscall.SyscallN(procGetAce.Addr(), uintptr(unsafe.Pointer(acl)), uintptr(aceIndex), uintptr(unsafe.Pointer(pAce)))
816 if r1 == 0 {
817 err = errnoErr(e1)
818 }
819 return
820 }
821
822 func GetLengthSid(sid *SID) (len uint32) {
823 r0, _, _ := syscall.SyscallN(procGetLengthSid.Addr(), uintptr(unsafe.Pointer(sid)))
824 len = uint32(r0)
825 return
826 }
827
828 func getNamedSecurityInfo(objectName string, objectType SE_OBJECT_TYPE, securityInformation SECURITY_INFORMATION, owner **SID, group **SID, dacl **ACL, sacl **ACL, sd **SECURITY_DESCRIPTOR) (ret error) {
829 var _p0 *uint16
830 _p0, ret = syscall.UTF16PtrFromString(objectName)
831 if ret != nil {
832 return
833 }
834 return _getNamedSecurityInfo(_p0, objectType, securityInformation, owner, group, dacl, sacl, sd)
835 }
836
837 func _getNamedSecurityInfo(objectName *uint16, objectType SE_OBJECT_TYPE, securityInformation SECURITY_INFORMATION, owner **SID, group **SID, dacl **ACL, sacl **ACL, sd **SECURITY_DESCRIPTOR) (ret error) {
838 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)))
839 if r0 != 0 {
840 ret = syscall.Errno(r0)
841 }
842 return
843 }
844
845 func getSecurityDescriptorControl(sd *SECURITY_DESCRIPTOR, control *SECURITY_DESCRIPTOR_CONTROL, revision *uint32) (err error) {
846 r1, _, e1 := syscall.SyscallN(procGetSecurityDescriptorControl.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(unsafe.Pointer(control)), uintptr(unsafe.Pointer(revision)))
847 if r1 == 0 {
848 err = errnoErr(e1)
849 }
850 return
851 }
852
853 func getSecurityDescriptorDacl(sd *SECURITY_DESCRIPTOR, daclPresent *bool, dacl **ACL, daclDefaulted *bool) (err error) {
854 var _p0 uint32
855 if *daclPresent {
856 _p0 = 1
857 }
858 var _p1 uint32
859 if *daclDefaulted {
860 _p1 = 1
861 }
862 r1, _, e1 := syscall.SyscallN(procGetSecurityDescriptorDacl.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(unsafe.Pointer(&_p0)), uintptr(unsafe.Pointer(dacl)), uintptr(unsafe.Pointer(&_p1)))
863 *daclPresent = _p0 != 0
864 *daclDefaulted = _p1 != 0
865 if r1 == 0 {
866 err = errnoErr(e1)
867 }
868 return
869 }
870
871 func getSecurityDescriptorGroup(sd *SECURITY_DESCRIPTOR, group **SID, groupDefaulted *bool) (err error) {
872 var _p0 uint32
873 if *groupDefaulted {
874 _p0 = 1
875 }
876 r1, _, e1 := syscall.SyscallN(procGetSecurityDescriptorGroup.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(unsafe.Pointer(group)), uintptr(unsafe.Pointer(&_p0)))
877 *groupDefaulted = _p0 != 0
878 if r1 == 0 {
879 err = errnoErr(e1)
880 }
881 return
882 }
883
884 func getSecurityDescriptorLength(sd *SECURITY_DESCRIPTOR) (len uint32) {
885 r0, _, _ := syscall.SyscallN(procGetSecurityDescriptorLength.Addr(), uintptr(unsafe.Pointer(sd)))
886 len = uint32(r0)
887 return
888 }
889
890 func getSecurityDescriptorOwner(sd *SECURITY_DESCRIPTOR, owner **SID, ownerDefaulted *bool) (err error) {
891 var _p0 uint32
892 if *ownerDefaulted {
893 _p0 = 1
894 }
895 r1, _, e1 := syscall.SyscallN(procGetSecurityDescriptorOwner.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(unsafe.Pointer(owner)), uintptr(unsafe.Pointer(&_p0)))
896 *ownerDefaulted = _p0 != 0
897 if r1 == 0 {
898 err = errnoErr(e1)
899 }
900 return
901 }
902
903 func getSecurityDescriptorRMControl(sd *SECURITY_DESCRIPTOR, rmControl *uint8) (ret error) {
904 r0, _, _ := syscall.SyscallN(procGetSecurityDescriptorRMControl.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(unsafe.Pointer(rmControl)))
905 if r0 != 0 {
906 ret = syscall.Errno(r0)
907 }
908 return
909 }
910
911 func getSecurityDescriptorSacl(sd *SECURITY_DESCRIPTOR, saclPresent *bool, sacl **ACL, saclDefaulted *bool) (err error) {
912 var _p0 uint32
913 if *saclPresent {
914 _p0 = 1
915 }
916 var _p1 uint32
917 if *saclDefaulted {
918 _p1 = 1
919 }
920 r1, _, e1 := syscall.SyscallN(procGetSecurityDescriptorSacl.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(unsafe.Pointer(&_p0)), uintptr(unsafe.Pointer(sacl)), uintptr(unsafe.Pointer(&_p1)))
921 *saclPresent = _p0 != 0
922 *saclDefaulted = _p1 != 0
923 if r1 == 0 {
924 err = errnoErr(e1)
925 }
926 return
927 }
928
929 func getSecurityInfo(handle Handle, objectType SE_OBJECT_TYPE, securityInformation SECURITY_INFORMATION, owner **SID, group **SID, dacl **ACL, sacl **ACL, sd **SECURITY_DESCRIPTOR) (ret error) {
930 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)))
931 if r0 != 0 {
932 ret = syscall.Errno(r0)
933 }
934 return
935 }
936
937 func getSidIdentifierAuthority(sid *SID) (authority *SidIdentifierAuthority) {
938 r0, _, _ := syscall.SyscallN(procGetSidIdentifierAuthority.Addr(), uintptr(unsafe.Pointer(sid)))
939 authority = (*SidIdentifierAuthority)(unsafe.Pointer(r0))
940 return
941 }
942
943 func getSidSubAuthority(sid *SID, index uint32) (subAuthority *uint32) {
944 r0, _, _ := syscall.SyscallN(procGetSidSubAuthority.Addr(), uintptr(unsafe.Pointer(sid)), uintptr(index))
945 subAuthority = (*uint32)(unsafe.Pointer(r0))
946 return
947 }
948
949 func getSidSubAuthorityCount(sid *SID) (count *uint8) {
950 r0, _, _ := syscall.SyscallN(procGetSidSubAuthorityCount.Addr(), uintptr(unsafe.Pointer(sid)))
951 count = (*uint8)(unsafe.Pointer(r0))
952 return
953 }
954
955 func GetTokenInformation(token Token, infoClass uint32, info *byte, infoLen uint32, returnedLen *uint32) (err error) {
956 r1, _, e1 := syscall.SyscallN(procGetTokenInformation.Addr(), uintptr(token), uintptr(infoClass), uintptr(unsafe.Pointer(info)), uintptr(infoLen), uintptr(unsafe.Pointer(returnedLen)))
957 if r1 == 0 {
958 err = errnoErr(e1)
959 }
960 return
961 }
962
963 func ImpersonateSelf(impersonationlevel uint32) (err error) {
964 r1, _, e1 := syscall.SyscallN(procImpersonateSelf.Addr(), uintptr(impersonationlevel))
965 if r1 == 0 {
966 err = errnoErr(e1)
967 }
968 return
969 }
970
971 func initializeSecurityDescriptor(absoluteSD *SECURITY_DESCRIPTOR, revision uint32) (err error) {
972 r1, _, e1 := syscall.SyscallN(procInitializeSecurityDescriptor.Addr(), uintptr(unsafe.Pointer(absoluteSD)), uintptr(revision))
973 if r1 == 0 {
974 err = errnoErr(e1)
975 }
976 return
977 }
978
979 func InitiateSystemShutdownEx(machineName *uint16, message *uint16, timeout uint32, forceAppsClosed bool, rebootAfterShutdown bool, reason uint32) (err error) {
980 var _p0 uint32
981 if forceAppsClosed {
982 _p0 = 1
983 }
984 var _p1 uint32
985 if rebootAfterShutdown {
986 _p1 = 1
987 }
988 r1, _, e1 := syscall.SyscallN(procInitiateSystemShutdownExW.Addr(), uintptr(unsafe.Pointer(machineName)), uintptr(unsafe.Pointer(message)), uintptr(timeout), uintptr(_p0), uintptr(_p1), uintptr(reason))
989 if r1 == 0 {
990 err = errnoErr(e1)
991 }
992 return
993 }
994
995 func isTokenRestricted(tokenHandle Token) (ret bool, err error) {
996 r0, _, e1 := syscall.SyscallN(procIsTokenRestricted.Addr(), uintptr(tokenHandle))
997 ret = r0 != 0
998 if !ret {
999 err = errnoErr(e1)
1000 }
1001 return
1002 }
1003
1004 func isValidSecurityDescriptor(sd *SECURITY_DESCRIPTOR) (isValid bool) {
1005 r0, _, _ := syscall.SyscallN(procIsValidSecurityDescriptor.Addr(), uintptr(unsafe.Pointer(sd)))
1006 isValid = r0 != 0
1007 return
1008 }
1009
1010 func isValidSid(sid *SID) (isValid bool) {
1011 r0, _, _ := syscall.SyscallN(procIsValidSid.Addr(), uintptr(unsafe.Pointer(sid)))
1012 isValid = r0 != 0
1013 return
1014 }
1015
1016 func isWellKnownSid(sid *SID, sidType WELL_KNOWN_SID_TYPE) (isWellKnown bool) {
1017 r0, _, _ := syscall.SyscallN(procIsWellKnownSid.Addr(), uintptr(unsafe.Pointer(sid)), uintptr(sidType))
1018 isWellKnown = r0 != 0
1019 return
1020 }
1021
1022 func LookupAccountName(systemName *uint16, accountName *uint16, sid *SID, sidLen *uint32, refdDomainName *uint16, refdDomainNameLen *uint32, use *uint32) (err error) {
1023 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)))
1024 if r1 == 0 {
1025 err = errnoErr(e1)
1026 }
1027 return
1028 }
1029
1030 func LookupAccountSid(systemName *uint16, sid *SID, name *uint16, nameLen *uint32, refdDomainName *uint16, refdDomainNameLen *uint32, use *uint32) (err error) {
1031 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)))
1032 if r1 == 0 {
1033 err = errnoErr(e1)
1034 }
1035 return
1036 }
1037
1038 func LookupPrivilegeValue(systemname *uint16, name *uint16, luid *LUID) (err error) {
1039 r1, _, e1 := syscall.SyscallN(procLookupPrivilegeValueW.Addr(), uintptr(unsafe.Pointer(systemname)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(luid)))
1040 if r1 == 0 {
1041 err = errnoErr(e1)
1042 }
1043 return
1044 }
1045
1046 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) {
1047 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)))
1048 if r1 == 0 {
1049 err = errnoErr(e1)
1050 }
1051 return
1052 }
1053
1054 func makeSelfRelativeSD(absoluteSD *SECURITY_DESCRIPTOR, selfRelativeSD *SECURITY_DESCRIPTOR, selfRelativeSDSize *uint32) (err error) {
1055 r1, _, e1 := syscall.SyscallN(procMakeSelfRelativeSD.Addr(), uintptr(unsafe.Pointer(absoluteSD)), uintptr(unsafe.Pointer(selfRelativeSD)), uintptr(unsafe.Pointer(selfRelativeSDSize)))
1056 if r1 == 0 {
1057 err = errnoErr(e1)
1058 }
1059 return
1060 }
1061
1062 func NotifyServiceStatusChange(service Handle, notifyMask uint32, notifier *SERVICE_NOTIFY) (ret error) {
1063 r0, _, _ := syscall.SyscallN(procNotifyServiceStatusChangeW.Addr(), uintptr(service), uintptr(notifyMask), uintptr(unsafe.Pointer(notifier)))
1064 if r0 != 0 {
1065 ret = syscall.Errno(r0)
1066 }
1067 return
1068 }
1069
1070 func OpenProcessToken(process Handle, access uint32, token *Token) (err error) {
1071 r1, _, e1 := syscall.SyscallN(procOpenProcessToken.Addr(), uintptr(process), uintptr(access), uintptr(unsafe.Pointer(token)))
1072 if r1 == 0 {
1073 err = errnoErr(e1)
1074 }
1075 return
1076 }
1077
1078 func OpenSCManager(machineName *uint16, databaseName *uint16, access uint32) (handle Handle, err error) {
1079 r0, _, e1 := syscall.SyscallN(procOpenSCManagerW.Addr(), uintptr(unsafe.Pointer(machineName)), uintptr(unsafe.Pointer(databaseName)), uintptr(access))
1080 handle = Handle(r0)
1081 if handle == 0 {
1082 err = errnoErr(e1)
1083 }
1084 return
1085 }
1086
1087 func OpenService(mgr Handle, serviceName *uint16, access uint32) (handle Handle, err error) {
1088 r0, _, e1 := syscall.SyscallN(procOpenServiceW.Addr(), uintptr(mgr), uintptr(unsafe.Pointer(serviceName)), uintptr(access))
1089 handle = Handle(r0)
1090 if handle == 0 {
1091 err = errnoErr(e1)
1092 }
1093 return
1094 }
1095
1096 func OpenThreadToken(thread Handle, access uint32, openAsSelf bool, token *Token) (err error) {
1097 var _p0 uint32
1098 if openAsSelf {
1099 _p0 = 1
1100 }
1101 r1, _, e1 := syscall.SyscallN(procOpenThreadToken.Addr(), uintptr(thread), uintptr(access), uintptr(_p0), uintptr(unsafe.Pointer(token)))
1102 if r1 == 0 {
1103 err = errnoErr(e1)
1104 }
1105 return
1106 }
1107
1108 func QueryServiceConfig2(service Handle, infoLevel uint32, buff *byte, buffSize uint32, bytesNeeded *uint32) (err error) {
1109 r1, _, e1 := syscall.SyscallN(procQueryServiceConfig2W.Addr(), uintptr(service), uintptr(infoLevel), uintptr(unsafe.Pointer(buff)), uintptr(buffSize), uintptr(unsafe.Pointer(bytesNeeded)))
1110 if r1 == 0 {
1111 err = errnoErr(e1)
1112 }
1113 return
1114 }
1115
1116 func QueryServiceConfig(service Handle, serviceConfig *QUERY_SERVICE_CONFIG, bufSize uint32, bytesNeeded *uint32) (err error) {
1117 r1, _, e1 := syscall.SyscallN(procQueryServiceConfigW.Addr(), uintptr(service), uintptr(unsafe.Pointer(serviceConfig)), uintptr(bufSize), uintptr(unsafe.Pointer(bytesNeeded)))
1118 if r1 == 0 {
1119 err = errnoErr(e1)
1120 }
1121 return
1122 }
1123
1124 func QueryServiceDynamicInformation(service Handle, infoLevel uint32, dynamicInfo unsafe.Pointer) (err error) {
1125 err = procQueryServiceDynamicInformation.Find()
1126 if err != nil {
1127 return
1128 }
1129 r1, _, e1 := syscall.SyscallN(procQueryServiceDynamicInformation.Addr(), uintptr(service), uintptr(infoLevel), uintptr(dynamicInfo))
1130 if r1 == 0 {
1131 err = errnoErr(e1)
1132 }
1133 return
1134 }
1135
1136 func QueryServiceLockStatus(mgr Handle, lockStatus *QUERY_SERVICE_LOCK_STATUS, bufSize uint32, bytesNeeded *uint32) (err error) {
1137 r1, _, e1 := syscall.SyscallN(procQueryServiceLockStatusW.Addr(), uintptr(mgr), uintptr(unsafe.Pointer(lockStatus)), uintptr(bufSize), uintptr(unsafe.Pointer(bytesNeeded)))
1138 if r1 == 0 {
1139 err = errnoErr(e1)
1140 }
1141 return
1142 }
1143
1144 func QueryServiceStatus(service Handle, status *SERVICE_STATUS) (err error) {
1145 r1, _, e1 := syscall.SyscallN(procQueryServiceStatus.Addr(), uintptr(service), uintptr(unsafe.Pointer(status)))
1146 if r1 == 0 {
1147 err = errnoErr(e1)
1148 }
1149 return
1150 }
1151
1152 func QueryServiceStatusEx(service Handle, infoLevel uint32, buff *byte, buffSize uint32, bytesNeeded *uint32) (err error) {
1153 r1, _, e1 := syscall.SyscallN(procQueryServiceStatusEx.Addr(), uintptr(service), uintptr(infoLevel), uintptr(unsafe.Pointer(buff)), uintptr(buffSize), uintptr(unsafe.Pointer(bytesNeeded)))
1154 if r1 == 0 {
1155 err = errnoErr(e1)
1156 }
1157 return
1158 }
1159
1160 func RegCloseKey(key Handle) (regerrno error) {
1161 r0, _, _ := syscall.SyscallN(procRegCloseKey.Addr(), uintptr(key))
1162 if r0 != 0 {
1163 regerrno = syscall.Errno(r0)
1164 }
1165 return
1166 }
1167
1168 func RegEnumKeyEx(key Handle, index uint32, name *uint16, nameLen *uint32, reserved *uint32, class *uint16, classLen *uint32, lastWriteTime *Filetime) (regerrno error) {
1169 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)))
1170 if r0 != 0 {
1171 regerrno = syscall.Errno(r0)
1172 }
1173 return
1174 }
1175
1176 func RegNotifyChangeKeyValue(key Handle, watchSubtree bool, notifyFilter uint32, event Handle, asynchronous bool) (regerrno error) {
1177 var _p0 uint32
1178 if watchSubtree {
1179 _p0 = 1
1180 }
1181 var _p1 uint32
1182 if asynchronous {
1183 _p1 = 1
1184 }
1185 r0, _, _ := syscall.SyscallN(procRegNotifyChangeKeyValue.Addr(), uintptr(key), uintptr(_p0), uintptr(notifyFilter), uintptr(event), uintptr(_p1))
1186 if r0 != 0 {
1187 regerrno = syscall.Errno(r0)
1188 }
1189 return
1190 }
1191
1192 func RegOpenKeyEx(key Handle, subkey *uint16, options uint32, desiredAccess uint32, result *Handle) (regerrno error) {
1193 r0, _, _ := syscall.SyscallN(procRegOpenKeyExW.Addr(), uintptr(key), uintptr(unsafe.Pointer(subkey)), uintptr(options), uintptr(desiredAccess), uintptr(unsafe.Pointer(result)))
1194 if r0 != 0 {
1195 regerrno = syscall.Errno(r0)
1196 }
1197 return
1198 }
1199
1200 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) {
1201 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)))
1202 if r0 != 0 {
1203 regerrno = syscall.Errno(r0)
1204 }
1205 return
1206 }
1207
1208 func RegQueryValueEx(key Handle, name *uint16, reserved *uint32, valtype *uint32, buf *byte, buflen *uint32) (regerrno error) {
1209 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)))
1210 if r0 != 0 {
1211 regerrno = syscall.Errno(r0)
1212 }
1213 return
1214 }
1215
1216 func RegisterEventSource(uncServerName *uint16, sourceName *uint16) (handle Handle, err error) {
1217 r0, _, e1 := syscall.SyscallN(procRegisterEventSourceW.Addr(), uintptr(unsafe.Pointer(uncServerName)), uintptr(unsafe.Pointer(sourceName)))
1218 handle = Handle(r0)
1219 if handle == 0 {
1220 err = errnoErr(e1)
1221 }
1222 return
1223 }
1224
1225 func RegisterServiceCtrlHandlerEx(serviceName *uint16, handlerProc uintptr, context uintptr) (handle Handle, err error) {
1226 r0, _, e1 := syscall.SyscallN(procRegisterServiceCtrlHandlerExW.Addr(), uintptr(unsafe.Pointer(serviceName)), uintptr(handlerProc), uintptr(context))
1227 handle = Handle(r0)
1228 if handle == 0 {
1229 err = errnoErr(e1)
1230 }
1231 return
1232 }
1233
1234 func ReportEvent(log Handle, etype uint16, category uint16, eventId uint32, usrSId uintptr, numStrings uint16, dataSize uint32, strings **uint16, rawData *byte) (err error) {
1235 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)))
1236 if r1 == 0 {
1237 err = errnoErr(e1)
1238 }
1239 return
1240 }
1241
1242 func RevertToSelf() (err error) {
1243 r1, _, e1 := syscall.SyscallN(procRevertToSelf.Addr())
1244 if r1 == 0 {
1245 err = errnoErr(e1)
1246 }
1247 return
1248 }
1249
1250 func setEntriesInAcl(countExplicitEntries uint32, explicitEntries *EXPLICIT_ACCESS, oldACL *ACL, newACL **ACL) (ret error) {
1251 r0, _, _ := syscall.SyscallN(procSetEntriesInAclW.Addr(), uintptr(countExplicitEntries), uintptr(unsafe.Pointer(explicitEntries)), uintptr(unsafe.Pointer(oldACL)), uintptr(unsafe.Pointer(newACL)))
1252 if r0 != 0 {
1253 ret = syscall.Errno(r0)
1254 }
1255 return
1256 }
1257
1258 func SetKernelObjectSecurity(handle Handle, securityInformation SECURITY_INFORMATION, securityDescriptor *SECURITY_DESCRIPTOR) (err error) {
1259 r1, _, e1 := syscall.SyscallN(procSetKernelObjectSecurity.Addr(), uintptr(handle), uintptr(securityInformation), uintptr(unsafe.Pointer(securityDescriptor)))
1260 if r1 == 0 {
1261 err = errnoErr(e1)
1262 }
1263 return
1264 }
1265
1266 func SetNamedSecurityInfo(objectName string, objectType SE_OBJECT_TYPE, securityInformation SECURITY_INFORMATION, owner *SID, group *SID, dacl *ACL, sacl *ACL) (ret error) {
1267 var _p0 *uint16
1268 _p0, ret = syscall.UTF16PtrFromString(objectName)
1269 if ret != nil {
1270 return
1271 }
1272 return _SetNamedSecurityInfo(_p0, objectType, securityInformation, owner, group, dacl, sacl)
1273 }
1274
1275 func _SetNamedSecurityInfo(objectName *uint16, objectType SE_OBJECT_TYPE, securityInformation SECURITY_INFORMATION, owner *SID, group *SID, dacl *ACL, sacl *ACL) (ret error) {
1276 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)))
1277 if r0 != 0 {
1278 ret = syscall.Errno(r0)
1279 }
1280 return
1281 }
1282
1283 func setSecurityDescriptorControl(sd *SECURITY_DESCRIPTOR, controlBitsOfInterest SECURITY_DESCRIPTOR_CONTROL, controlBitsToSet SECURITY_DESCRIPTOR_CONTROL) (err error) {
1284 r1, _, e1 := syscall.SyscallN(procSetSecurityDescriptorControl.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(controlBitsOfInterest), uintptr(controlBitsToSet))
1285 if r1 == 0 {
1286 err = errnoErr(e1)
1287 }
1288 return
1289 }
1290
1291 func setSecurityDescriptorDacl(sd *SECURITY_DESCRIPTOR, daclPresent bool, dacl *ACL, daclDefaulted bool) (err error) {
1292 var _p0 uint32
1293 if daclPresent {
1294 _p0 = 1
1295 }
1296 var _p1 uint32
1297 if daclDefaulted {
1298 _p1 = 1
1299 }
1300 r1, _, e1 := syscall.SyscallN(procSetSecurityDescriptorDacl.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(_p0), uintptr(unsafe.Pointer(dacl)), uintptr(_p1))
1301 if r1 == 0 {
1302 err = errnoErr(e1)
1303 }
1304 return
1305 }
1306
1307 func setSecurityDescriptorGroup(sd *SECURITY_DESCRIPTOR, group *SID, groupDefaulted bool) (err error) {
1308 var _p0 uint32
1309 if groupDefaulted {
1310 _p0 = 1
1311 }
1312 r1, _, e1 := syscall.SyscallN(procSetSecurityDescriptorGroup.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(unsafe.Pointer(group)), uintptr(_p0))
1313 if r1 == 0 {
1314 err = errnoErr(e1)
1315 }
1316 return
1317 }
1318
1319 func setSecurityDescriptorOwner(sd *SECURITY_DESCRIPTOR, owner *SID, ownerDefaulted bool) (err error) {
1320 var _p0 uint32
1321 if ownerDefaulted {
1322 _p0 = 1
1323 }
1324 r1, _, e1 := syscall.SyscallN(procSetSecurityDescriptorOwner.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(unsafe.Pointer(owner)), uintptr(_p0))
1325 if r1 == 0 {
1326 err = errnoErr(e1)
1327 }
1328 return
1329 }
1330
1331 func setSecurityDescriptorRMControl(sd *SECURITY_DESCRIPTOR, rmControl *uint8) {
1332 syscall.SyscallN(procSetSecurityDescriptorRMControl.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(unsafe.Pointer(rmControl)))
1333 return
1334 }
1335
1336 func setSecurityDescriptorSacl(sd *SECURITY_DESCRIPTOR, saclPresent bool, sacl *ACL, saclDefaulted bool) (err error) {
1337 var _p0 uint32
1338 if saclPresent {
1339 _p0 = 1
1340 }
1341 var _p1 uint32
1342 if saclDefaulted {
1343 _p1 = 1
1344 }
1345 r1, _, e1 := syscall.SyscallN(procSetSecurityDescriptorSacl.Addr(), uintptr(unsafe.Pointer(sd)), uintptr(_p0), uintptr(unsafe.Pointer(sacl)), uintptr(_p1))
1346 if r1 == 0 {
1347 err = errnoErr(e1)
1348 }
1349 return
1350 }
1351
1352 func SetSecurityInfo(handle Handle, objectType SE_OBJECT_TYPE, securityInformation SECURITY_INFORMATION, owner *SID, group *SID, dacl *ACL, sacl *ACL) (ret error) {
1353 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)))
1354 if r0 != 0 {
1355 ret = syscall.Errno(r0)
1356 }
1357 return
1358 }
1359
1360 func SetServiceStatus(service Handle, serviceStatus *SERVICE_STATUS) (err error) {
1361 r1, _, e1 := syscall.SyscallN(procSetServiceStatus.Addr(), uintptr(service), uintptr(unsafe.Pointer(serviceStatus)))
1362 if r1 == 0 {
1363 err = errnoErr(e1)
1364 }
1365 return
1366 }
1367
1368 func SetThreadToken(thread *Handle, token Token) (err error) {
1369 r1, _, e1 := syscall.SyscallN(procSetThreadToken.Addr(), uintptr(unsafe.Pointer(thread)), uintptr(token))
1370 if r1 == 0 {
1371 err = errnoErr(e1)
1372 }
1373 return
1374 }
1375
1376 func SetTokenInformation(token Token, infoClass uint32, info *byte, infoLen uint32) (err error) {
1377 r1, _, e1 := syscall.SyscallN(procSetTokenInformation.Addr(), uintptr(token), uintptr(infoClass), uintptr(unsafe.Pointer(info)), uintptr(infoLen))
1378 if r1 == 0 {
1379 err = errnoErr(e1)
1380 }
1381 return
1382 }
1383
1384 func StartServiceCtrlDispatcher(serviceTable *SERVICE_TABLE_ENTRY) (err error) {
1385 r1, _, e1 := syscall.SyscallN(procStartServiceCtrlDispatcherW.Addr(), uintptr(unsafe.Pointer(serviceTable)))
1386 if r1 == 0 {
1387 err = errnoErr(e1)
1388 }
1389 return
1390 }
1391
1392 func StartService(service Handle, numArgs uint32, argVectors **uint16) (err error) {
1393 r1, _, e1 := syscall.SyscallN(procStartServiceW.Addr(), uintptr(service), uintptr(numArgs), uintptr(unsafe.Pointer(argVectors)))
1394 if r1 == 0 {
1395 err = errnoErr(e1)
1396 }
1397 return
1398 }
1399
1400 func CertAddCertificateContextToStore(store Handle, certContext *CertContext, addDisposition uint32, storeContext **CertContext) (err error) {
1401 r1, _, e1 := syscall.SyscallN(procCertAddCertificateContextToStore.Addr(), uintptr(store), uintptr(unsafe.Pointer(certContext)), uintptr(addDisposition), uintptr(unsafe.Pointer(storeContext)))
1402 if r1 == 0 {
1403 err = errnoErr(e1)
1404 }
1405 return
1406 }
1407
1408 func CertCloseStore(store Handle, flags uint32) (err error) {
1409 r1, _, e1 := syscall.SyscallN(procCertCloseStore.Addr(), uintptr(store), uintptr(flags))
1410 if r1 == 0 {
1411 err = errnoErr(e1)
1412 }
1413 return
1414 }
1415
1416 func CertCreateCertificateContext(certEncodingType uint32, certEncoded *byte, encodedLen uint32) (context *CertContext, err error) {
1417 r0, _, e1 := syscall.SyscallN(procCertCreateCertificateContext.Addr(), uintptr(certEncodingType), uintptr(unsafe.Pointer(certEncoded)), uintptr(encodedLen))
1418 context = (*CertContext)(unsafe.Pointer(r0))
1419 if context == nil {
1420 err = errnoErr(e1)
1421 }
1422 return
1423 }
1424
1425 func CertDeleteCertificateFromStore(certContext *CertContext) (err error) {
1426 r1, _, e1 := syscall.SyscallN(procCertDeleteCertificateFromStore.Addr(), uintptr(unsafe.Pointer(certContext)))
1427 if r1 == 0 {
1428 err = errnoErr(e1)
1429 }
1430 return
1431 }
1432
1433 func CertDuplicateCertificateContext(certContext *CertContext) (dupContext *CertContext) {
1434 r0, _, _ := syscall.SyscallN(procCertDuplicateCertificateContext.Addr(), uintptr(unsafe.Pointer(certContext)))
1435 dupContext = (*CertContext)(unsafe.Pointer(r0))
1436 return
1437 }
1438
1439 func CertEnumCertificatesInStore(store Handle, prevContext *CertContext) (context *CertContext, err error) {
1440 r0, _, e1 := syscall.SyscallN(procCertEnumCertificatesInStore.Addr(), uintptr(store), uintptr(unsafe.Pointer(prevContext)))
1441 context = (*CertContext)(unsafe.Pointer(r0))
1442 if context == nil {
1443 err = errnoErr(e1)
1444 }
1445 return
1446 }
1447
1448 func CertFindCertificateInStore(store Handle, certEncodingType uint32, findFlags uint32, findType uint32, findPara unsafe.Pointer, prevCertContext *CertContext) (cert *CertContext, err error) {
1449 r0, _, e1 := syscall.SyscallN(procCertFindCertificateInStore.Addr(), uintptr(store), uintptr(certEncodingType), uintptr(findFlags), uintptr(findType), uintptr(findPara), uintptr(unsafe.Pointer(prevCertContext)))
1450 cert = (*CertContext)(unsafe.Pointer(r0))
1451 if cert == nil {
1452 err = errnoErr(e1)
1453 }
1454 return
1455 }
1456
1457 func CertFindChainInStore(store Handle, certEncodingType uint32, findFlags uint32, findType uint32, findPara unsafe.Pointer, prevChainContext *CertChainContext) (certchain *CertChainContext, err error) {
1458 r0, _, e1 := syscall.SyscallN(procCertFindChainInStore.Addr(), uintptr(store), uintptr(certEncodingType), uintptr(findFlags), uintptr(findType), uintptr(findPara), uintptr(unsafe.Pointer(prevChainContext)))
1459 certchain = (*CertChainContext)(unsafe.Pointer(r0))
1460 if certchain == nil {
1461 err = errnoErr(e1)
1462 }
1463 return
1464 }
1465
1466 func CertFindExtension(objId *byte, countExtensions uint32, extensions *CertExtension) (ret *CertExtension) {
1467 r0, _, _ := syscall.SyscallN(procCertFindExtension.Addr(), uintptr(unsafe.Pointer(objId)), uintptr(countExtensions), uintptr(unsafe.Pointer(extensions)))
1468 ret = (*CertExtension)(unsafe.Pointer(r0))
1469 return
1470 }
1471
1472 func CertFreeCertificateChain(ctx *CertChainContext) {
1473 syscall.SyscallN(procCertFreeCertificateChain.Addr(), uintptr(unsafe.Pointer(ctx)))
1474 return
1475 }
1476
1477 func CertFreeCertificateContext(ctx *CertContext) (err error) {
1478 r1, _, e1 := syscall.SyscallN(procCertFreeCertificateContext.Addr(), uintptr(unsafe.Pointer(ctx)))
1479 if r1 == 0 {
1480 err = errnoErr(e1)
1481 }
1482 return
1483 }
1484
1485 func CertGetCertificateChain(engine Handle, leaf *CertContext, time *Filetime, additionalStore Handle, para *CertChainPara, flags uint32, reserved uintptr, chainCtx **CertChainContext) (err error) {
1486 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)))
1487 if r1 == 0 {
1488 err = errnoErr(e1)
1489 }
1490 return
1491 }
1492
1493 func CertGetNameString(certContext *CertContext, nameType uint32, flags uint32, typePara unsafe.Pointer, name *uint16, size uint32) (chars uint32) {
1494 r0, _, _ := syscall.SyscallN(procCertGetNameStringW.Addr(), uintptr(unsafe.Pointer(certContext)), uintptr(nameType), uintptr(flags), uintptr(typePara), uintptr(unsafe.Pointer(name)), uintptr(size))
1495 chars = uint32(r0)
1496 return
1497 }
1498
1499 func CertOpenStore(storeProvider uintptr, msgAndCertEncodingType uint32, cryptProv uintptr, flags uint32, para uintptr) (handle Handle, err error) {
1500 r0, _, e1 := syscall.SyscallN(procCertOpenStore.Addr(), uintptr(storeProvider), uintptr(msgAndCertEncodingType), uintptr(cryptProv), uintptr(flags), uintptr(para))
1501 handle = Handle(r0)
1502 if handle == 0 {
1503 err = errnoErr(e1)
1504 }
1505 return
1506 }
1507
1508 func CertOpenSystemStore(hprov Handle, name *uint16) (store Handle, err error) {
1509 r0, _, e1 := syscall.SyscallN(procCertOpenSystemStoreW.Addr(), uintptr(hprov), uintptr(unsafe.Pointer(name)))
1510 store = Handle(r0)
1511 if store == 0 {
1512 err = errnoErr(e1)
1513 }
1514 return
1515 }
1516
1517 func CertVerifyCertificateChainPolicy(policyOID uintptr, chain *CertChainContext, para *CertChainPolicyPara, status *CertChainPolicyStatus) (err error) {
1518 r1, _, e1 := syscall.SyscallN(procCertVerifyCertificateChainPolicy.Addr(), uintptr(policyOID), uintptr(unsafe.Pointer(chain)), uintptr(unsafe.Pointer(para)), uintptr(unsafe.Pointer(status)))
1519 if r1 == 0 {
1520 err = errnoErr(e1)
1521 }
1522 return
1523 }
1524
1525 func CryptAcquireCertificatePrivateKey(cert *CertContext, flags uint32, parameters unsafe.Pointer, cryptProvOrNCryptKey *Handle, keySpec *uint32, callerFreeProvOrNCryptKey *bool) (err error) {
1526 var _p0 uint32
1527 if *callerFreeProvOrNCryptKey {
1528 _p0 = 1
1529 }
1530 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)))
1531 *callerFreeProvOrNCryptKey = _p0 != 0
1532 if r1 == 0 {
1533 err = errnoErr(e1)
1534 }
1535 return
1536 }
1537
1538 func CryptDecodeObject(encodingType uint32, structType *byte, encodedBytes *byte, lenEncodedBytes uint32, flags uint32, decoded unsafe.Pointer, decodedLen *uint32) (err error) {
1539 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)))
1540 if r1 == 0 {
1541 err = errnoErr(e1)
1542 }
1543 return
1544 }
1545
1546 func CryptProtectData(dataIn *DataBlob, name *uint16, optionalEntropy *DataBlob, reserved uintptr, promptStruct *CryptProtectPromptStruct, flags uint32, dataOut *DataBlob) (err error) {
1547 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)))
1548 if r1 == 0 {
1549 err = errnoErr(e1)
1550 }
1551 return
1552 }
1553
1554 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) {
1555 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)))
1556 if r1 == 0 {
1557 err = errnoErr(e1)
1558 }
1559 return
1560 }
1561
1562 func CryptUnprotectData(dataIn *DataBlob, name **uint16, optionalEntropy *DataBlob, reserved uintptr, promptStruct *CryptProtectPromptStruct, flags uint32, dataOut *DataBlob) (err error) {
1563 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)))
1564 if r1 == 0 {
1565 err = errnoErr(e1)
1566 }
1567 return
1568 }
1569
1570 func PFXImportCertStore(pfx *CryptDataBlob, password *uint16, flags uint32) (store Handle, err error) {
1571 r0, _, e1 := syscall.SyscallN(procPFXImportCertStore.Addr(), uintptr(unsafe.Pointer(pfx)), uintptr(unsafe.Pointer(password)), uintptr(flags))
1572 store = Handle(r0)
1573 if store == 0 {
1574 err = errnoErr(e1)
1575 }
1576 return
1577 }
1578
1579 func DnsNameCompare(name1 *uint16, name2 *uint16) (same bool) {
1580 r0, _, _ := syscall.SyscallN(procDnsNameCompare_W.Addr(), uintptr(unsafe.Pointer(name1)), uintptr(unsafe.Pointer(name2)))
1581 same = r0 != 0
1582 return
1583 }
1584
1585 func DnsQuery(name string, qtype uint16, options uint32, extra *byte, qrs **DNSRecord, pr *byte) (status error) {
1586 var _p0 *uint16
1587 _p0, status = syscall.UTF16PtrFromString(name)
1588 if status != nil {
1589 return
1590 }
1591 return _DnsQuery(_p0, qtype, options, extra, qrs, pr)
1592 }
1593
1594 func _DnsQuery(name *uint16, qtype uint16, options uint32, extra *byte, qrs **DNSRecord, pr *byte) (status error) {
1595 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)))
1596 if r0 != 0 {
1597 status = syscall.Errno(r0)
1598 }
1599 return
1600 }
1601
1602 func DnsRecordListFree(rl *DNSRecord, freetype uint32) {
1603 syscall.SyscallN(procDnsRecordListFree.Addr(), uintptr(unsafe.Pointer(rl)), uintptr(freetype))
1604 return
1605 }
1606
1607 func DwmGetWindowAttribute(hwnd HWND, attribute uint32, value unsafe.Pointer, size uint32) (ret error) {
1608 r0, _, _ := syscall.SyscallN(procDwmGetWindowAttribute.Addr(), uintptr(hwnd), uintptr(attribute), uintptr(value), uintptr(size))
1609 if r0 != 0 {
1610 ret = syscall.Errno(r0)
1611 }
1612 return
1613 }
1614
1615 func DwmSetWindowAttribute(hwnd HWND, attribute uint32, value unsafe.Pointer, size uint32) (ret error) {
1616 r0, _, _ := syscall.SyscallN(procDwmSetWindowAttribute.Addr(), uintptr(hwnd), uintptr(attribute), uintptr(value), uintptr(size))
1617 if r0 != 0 {
1618 ret = syscall.Errno(r0)
1619 }
1620 return
1621 }
1622
1623 func CancelMibChangeNotify2(notificationHandle Handle) (errcode error) {
1624 r0, _, _ := syscall.SyscallN(procCancelMibChangeNotify2.Addr(), uintptr(notificationHandle))
1625 if r0 != 0 {
1626 errcode = syscall.Errno(r0)
1627 }
1628 return
1629 }
1630
1631 func FreeMibTable(memory unsafe.Pointer) {
1632 syscall.SyscallN(procFreeMibTable.Addr(), uintptr(memory))
1633 return
1634 }
1635
1636 func GetAdaptersAddresses(family uint32, flags uint32, reserved uintptr, adapterAddresses *IpAdapterAddresses, sizePointer *uint32) (errcode error) {
1637 r0, _, _ := syscall.SyscallN(procGetAdaptersAddresses.Addr(), uintptr(family), uintptr(flags), uintptr(reserved), uintptr(unsafe.Pointer(adapterAddresses)), uintptr(unsafe.Pointer(sizePointer)))
1638 if r0 != 0 {
1639 errcode = syscall.Errno(r0)
1640 }
1641 return
1642 }
1643
1644 func GetAdaptersInfo(ai *IpAdapterInfo, ol *uint32) (errcode error) {
1645 r0, _, _ := syscall.SyscallN(procGetAdaptersInfo.Addr(), uintptr(unsafe.Pointer(ai)), uintptr(unsafe.Pointer(ol)))
1646 if r0 != 0 {
1647 errcode = syscall.Errno(r0)
1648 }
1649 return
1650 }
1651
1652 func getBestInterfaceEx(sockaddr unsafe.Pointer, pdwBestIfIndex *uint32) (errcode error) {
1653 r0, _, _ := syscall.SyscallN(procGetBestInterfaceEx.Addr(), uintptr(sockaddr), uintptr(unsafe.Pointer(pdwBestIfIndex)))
1654 if r0 != 0 {
1655 errcode = syscall.Errno(r0)
1656 }
1657 return
1658 }
1659
1660 func GetIfEntry(pIfRow *MibIfRow) (errcode error) {
1661 r0, _, _ := syscall.SyscallN(procGetIfEntry.Addr(), uintptr(unsafe.Pointer(pIfRow)))
1662 if r0 != 0 {
1663 errcode = syscall.Errno(r0)
1664 }
1665 return
1666 }
1667
1668 func GetIfEntry2Ex(level uint32, row *MibIfRow2) (errcode error) {
1669 r0, _, _ := syscall.SyscallN(procGetIfEntry2Ex.Addr(), uintptr(level), uintptr(unsafe.Pointer(row)))
1670 if r0 != 0 {
1671 errcode = syscall.Errno(r0)
1672 }
1673 return
1674 }
1675
1676 func GetIpForwardEntry2(row *MibIpForwardRow2) (errcode error) {
1677 r0, _, _ := syscall.SyscallN(procGetIpForwardEntry2.Addr(), uintptr(unsafe.Pointer(row)))
1678 if r0 != 0 {
1679 errcode = syscall.Errno(r0)
1680 }
1681 return
1682 }
1683
1684 func GetIpForwardTable2(family uint16, table **MibIpForwardTable2) (errcode error) {
1685 r0, _, _ := syscall.SyscallN(procGetIpForwardTable2.Addr(), uintptr(family), uintptr(unsafe.Pointer(table)))
1686 if r0 != 0 {
1687 errcode = syscall.Errno(r0)
1688 }
1689 return
1690 }
1691
1692 func GetUnicastIpAddressEntry(row *MibUnicastIpAddressRow) (errcode error) {
1693 r0, _, _ := syscall.SyscallN(procGetUnicastIpAddressEntry.Addr(), uintptr(unsafe.Pointer(row)))
1694 if r0 != 0 {
1695 errcode = syscall.Errno(r0)
1696 }
1697 return
1698 }
1699
1700 func NotifyIpInterfaceChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) {
1701 var _p0 uint32
1702 if initialNotification {
1703 _p0 = 1
1704 }
1705 r0, _, _ := syscall.SyscallN(procNotifyIpInterfaceChange.Addr(), uintptr(family), uintptr(callback), uintptr(callerContext), uintptr(_p0), uintptr(unsafe.Pointer(notificationHandle)))
1706 if r0 != 0 {
1707 errcode = syscall.Errno(r0)
1708 }
1709 return
1710 }
1711
1712 func NotifyRouteChange2(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) {
1713 var _p0 uint32
1714 if initialNotification {
1715 _p0 = 1
1716 }
1717 r0, _, _ := syscall.SyscallN(procNotifyRouteChange2.Addr(), uintptr(family), uintptr(callback), uintptr(callerContext), uintptr(_p0), uintptr(unsafe.Pointer(notificationHandle)))
1718 if r0 != 0 {
1719 errcode = syscall.Errno(r0)
1720 }
1721 return
1722 }
1723
1724 func NotifyUnicastIpAddressChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) {
1725 var _p0 uint32
1726 if initialNotification {
1727 _p0 = 1
1728 }
1729 r0, _, _ := syscall.SyscallN(procNotifyUnicastIpAddressChange.Addr(), uintptr(family), uintptr(callback), uintptr(callerContext), uintptr(_p0), uintptr(unsafe.Pointer(notificationHandle)))
1730 if r0 != 0 {
1731 errcode = syscall.Errno(r0)
1732 }
1733 return
1734 }
1735
1736 func AddDllDirectory(path *uint16) (cookie uintptr, err error) {
1737 r0, _, e1 := syscall.SyscallN(procAddDllDirectory.Addr(), uintptr(unsafe.Pointer(path)))
1738 cookie = uintptr(r0)
1739 if cookie == 0 {
1740 err = errnoErr(e1)
1741 }
1742 return
1743 }
1744
1745 func AssignProcessToJobObject(job Handle, process Handle) (err error) {
1746 r1, _, e1 := syscall.SyscallN(procAssignProcessToJobObject.Addr(), uintptr(job), uintptr(process))
1747 if r1 == 0 {
1748 err = errnoErr(e1)
1749 }
1750 return
1751 }
1752
1753 func CancelIo(s Handle) (err error) {
1754 r1, _, e1 := syscall.SyscallN(procCancelIo.Addr(), uintptr(s))
1755 if r1 == 0 {
1756 err = errnoErr(e1)
1757 }
1758 return
1759 }
1760
1761 func CancelIoEx(s Handle, o *Overlapped) (err error) {
1762 r1, _, e1 := syscall.SyscallN(procCancelIoEx.Addr(), uintptr(s), uintptr(unsafe.Pointer(o)))
1763 if r1 == 0 {
1764 err = errnoErr(e1)
1765 }
1766 return
1767 }
1768
1769 func ClearCommBreak(handle Handle) (err error) {
1770 r1, _, e1 := syscall.SyscallN(procClearCommBreak.Addr(), uintptr(handle))
1771 if r1 == 0 {
1772 err = errnoErr(e1)
1773 }
1774 return
1775 }
1776
1777 func ClearCommError(handle Handle, lpErrors *uint32, lpStat *ComStat) (err error) {
1778 r1, _, e1 := syscall.SyscallN(procClearCommError.Addr(), uintptr(handle), uintptr(unsafe.Pointer(lpErrors)), uintptr(unsafe.Pointer(lpStat)))
1779 if r1 == 0 {
1780 err = errnoErr(e1)
1781 }
1782 return
1783 }
1784
1785 func CloseHandle(handle Handle) (err error) {
1786 r1, _, e1 := syscall.SyscallN(procCloseHandle.Addr(), uintptr(handle))
1787 if r1 == 0 {
1788 err = errnoErr(e1)
1789 }
1790 return
1791 }
1792
1793 func ClosePseudoConsole(console Handle) {
1794 syscall.SyscallN(procClosePseudoConsole.Addr(), uintptr(console))
1795 return
1796 }
1797
1798 func ConnectNamedPipe(pipe Handle, overlapped *Overlapped) (err error) {
1799 r1, _, e1 := syscall.SyscallN(procConnectNamedPipe.Addr(), uintptr(pipe), uintptr(unsafe.Pointer(overlapped)))
1800 if r1 == 0 {
1801 err = errnoErr(e1)
1802 }
1803 return
1804 }
1805
1806 func CreateDirectory(path *uint16, sa *SecurityAttributes) (err error) {
1807 r1, _, e1 := syscall.SyscallN(procCreateDirectoryW.Addr(), uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(sa)))
1808 if r1 == 0 {
1809 err = errnoErr(e1)
1810 }
1811 return
1812 }
1813
1814 func CreateEventEx(eventAttrs *SecurityAttributes, name *uint16, flags uint32, desiredAccess uint32) (handle Handle, err error) {
1815 r0, _, e1 := syscall.SyscallN(procCreateEventExW.Addr(), uintptr(unsafe.Pointer(eventAttrs)), uintptr(unsafe.Pointer(name)), uintptr(flags), uintptr(desiredAccess))
1816 handle = Handle(r0)
1817 if handle == 0 || e1 == ERROR_ALREADY_EXISTS {
1818 err = errnoErr(e1)
1819 }
1820 return
1821 }
1822
1823 func CreateEvent(eventAttrs *SecurityAttributes, manualReset uint32, initialState uint32, name *uint16) (handle Handle, err error) {
1824 r0, _, e1 := syscall.SyscallN(procCreateEventW.Addr(), uintptr(unsafe.Pointer(eventAttrs)), uintptr(manualReset), uintptr(initialState), uintptr(unsafe.Pointer(name)))
1825 handle = Handle(r0)
1826 if handle == 0 || e1 == ERROR_ALREADY_EXISTS {
1827 err = errnoErr(e1)
1828 }
1829 return
1830 }
1831
1832 func CreateFileMapping(fhandle Handle, sa *SecurityAttributes, prot uint32, maxSizeHigh uint32, maxSizeLow uint32, name *uint16) (handle Handle, err error) {
1833 r0, _, e1 := syscall.SyscallN(procCreateFileMappingW.Addr(), uintptr(fhandle), uintptr(unsafe.Pointer(sa)), uintptr(prot), uintptr(maxSizeHigh), uintptr(maxSizeLow), uintptr(unsafe.Pointer(name)))
1834 handle = Handle(r0)
1835 if handle == 0 || e1 == ERROR_ALREADY_EXISTS {
1836 err = errnoErr(e1)
1837 }
1838 return
1839 }
1840
1841 func CreateFile(name *uint16, access uint32, mode uint32, sa *SecurityAttributes, createmode uint32, attrs uint32, templatefile Handle) (handle Handle, err error) {
1842 r0, _, e1 := syscall.SyscallN(procCreateFileW.Addr(), uintptr(unsafe.Pointer(name)), uintptr(access), uintptr(mode), uintptr(unsafe.Pointer(sa)), uintptr(createmode), uintptr(attrs), uintptr(templatefile))
1843 handle = Handle(r0)
1844 if handle == InvalidHandle {
1845 err = errnoErr(e1)
1846 }
1847 return
1848 }
1849
1850 func CreateHardLink(filename *uint16, existingfilename *uint16, reserved uintptr) (err error) {
1851 r1, _, e1 := syscall.SyscallN(procCreateHardLinkW.Addr(), uintptr(unsafe.Pointer(filename)), uintptr(unsafe.Pointer(existingfilename)), uintptr(reserved))
1852 if r1&0xff == 0 {
1853 err = errnoErr(e1)
1854 }
1855 return
1856 }
1857
1858 func CreateIoCompletionPort(filehandle Handle, cphandle Handle, key uintptr, threadcnt uint32) (handle Handle, err error) {
1859 r0, _, e1 := syscall.SyscallN(procCreateIoCompletionPort.Addr(), uintptr(filehandle), uintptr(cphandle), uintptr(key), uintptr(threadcnt))
1860 handle = Handle(r0)
1861 if handle == 0 {
1862 err = errnoErr(e1)
1863 }
1864 return
1865 }
1866
1867 func CreateJobObject(jobAttr *SecurityAttributes, name *uint16) (handle Handle, err error) {
1868 r0, _, e1 := syscall.SyscallN(procCreateJobObjectW.Addr(), uintptr(unsafe.Pointer(jobAttr)), uintptr(unsafe.Pointer(name)))
1869 handle = Handle(r0)
1870 if handle == 0 {
1871 err = errnoErr(e1)
1872 }
1873 return
1874 }
1875
1876 func CreateMutexEx(mutexAttrs *SecurityAttributes, name *uint16, flags uint32, desiredAccess uint32) (handle Handle, err error) {
1877 r0, _, e1 := syscall.SyscallN(procCreateMutexExW.Addr(), uintptr(unsafe.Pointer(mutexAttrs)), uintptr(unsafe.Pointer(name)), uintptr(flags), uintptr(desiredAccess))
1878 handle = Handle(r0)
1879 if handle == 0 || e1 == ERROR_ALREADY_EXISTS {
1880 err = errnoErr(e1)
1881 }
1882 return
1883 }
1884
1885 func CreateMutex(mutexAttrs *SecurityAttributes, initialOwner bool, name *uint16) (handle Handle, err error) {
1886 var _p0 uint32
1887 if initialOwner {
1888 _p0 = 1
1889 }
1890 r0, _, e1 := syscall.SyscallN(procCreateMutexW.Addr(), uintptr(unsafe.Pointer(mutexAttrs)), uintptr(_p0), uintptr(unsafe.Pointer(name)))
1891 handle = Handle(r0)
1892 if handle == 0 || e1 == ERROR_ALREADY_EXISTS {
1893 err = errnoErr(e1)
1894 }
1895 return
1896 }
1897
1898 func CreateNamedPipe(name *uint16, flags uint32, pipeMode uint32, maxInstances uint32, outSize uint32, inSize uint32, defaultTimeout uint32, sa *SecurityAttributes) (handle Handle, err error) {
1899 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)))
1900 handle = Handle(r0)
1901 if handle == InvalidHandle {
1902 err = errnoErr(e1)
1903 }
1904 return
1905 }
1906
1907 func CreatePipe(readhandle *Handle, writehandle *Handle, sa *SecurityAttributes, size uint32) (err error) {
1908 r1, _, e1 := syscall.SyscallN(procCreatePipe.Addr(), uintptr(unsafe.Pointer(readhandle)), uintptr(unsafe.Pointer(writehandle)), uintptr(unsafe.Pointer(sa)), uintptr(size))
1909 if r1 == 0 {
1910 err = errnoErr(e1)
1911 }
1912 return
1913 }
1914
1915 func CreateProcess(appName *uint16, commandLine *uint16, procSecurity *SecurityAttributes, threadSecurity *SecurityAttributes, inheritHandles bool, creationFlags uint32, env *uint16, currentDir *uint16, startupInfo *StartupInfo, outProcInfo *ProcessInformation) (err error) {
1916 var _p0 uint32
1917 if inheritHandles {
1918 _p0 = 1
1919 }
1920 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)))
1921 if r1 == 0 {
1922 err = errnoErr(e1)
1923 }
1924 return
1925 }
1926
1927 func createPseudoConsole(size uint32, in Handle, out Handle, flags uint32, pconsole *Handle) (hr error) {
1928 r0, _, _ := syscall.SyscallN(procCreatePseudoConsole.Addr(), uintptr(size), uintptr(in), uintptr(out), uintptr(flags), uintptr(unsafe.Pointer(pconsole)))
1929 if r0 != 0 {
1930 hr = syscall.Errno(r0)
1931 }
1932 return
1933 }
1934
1935 func CreateSymbolicLink(symlinkfilename *uint16, targetfilename *uint16, flags uint32) (err error) {
1936 r1, _, e1 := syscall.SyscallN(procCreateSymbolicLinkW.Addr(), uintptr(unsafe.Pointer(symlinkfilename)), uintptr(unsafe.Pointer(targetfilename)), uintptr(flags))
1937 if r1&0xff == 0 {
1938 err = errnoErr(e1)
1939 }
1940 return
1941 }
1942
1943 func CreateToolhelp32Snapshot(flags uint32, processId uint32) (handle Handle, err error) {
1944 r0, _, e1 := syscall.SyscallN(procCreateToolhelp32Snapshot.Addr(), uintptr(flags), uintptr(processId))
1945 handle = Handle(r0)
1946 if handle == InvalidHandle {
1947 err = errnoErr(e1)
1948 }
1949 return
1950 }
1951
1952 func DefineDosDevice(flags uint32, deviceName *uint16, targetPath *uint16) (err error) {
1953 r1, _, e1 := syscall.SyscallN(procDefineDosDeviceW.Addr(), uintptr(flags), uintptr(unsafe.Pointer(deviceName)), uintptr(unsafe.Pointer(targetPath)))
1954 if r1 == 0 {
1955 err = errnoErr(e1)
1956 }
1957 return
1958 }
1959
1960 func DeleteFile(path *uint16) (err error) {
1961 r1, _, e1 := syscall.SyscallN(procDeleteFileW.Addr(), uintptr(unsafe.Pointer(path)))
1962 if r1 == 0 {
1963 err = errnoErr(e1)
1964 }
1965 return
1966 }
1967
1968 func deleteProcThreadAttributeList(attrlist *ProcThreadAttributeList) {
1969 syscall.SyscallN(procDeleteProcThreadAttributeList.Addr(), uintptr(unsafe.Pointer(attrlist)))
1970 return
1971 }
1972
1973 func DeleteVolumeMountPoint(volumeMountPoint *uint16) (err error) {
1974 r1, _, e1 := syscall.SyscallN(procDeleteVolumeMountPointW.Addr(), uintptr(unsafe.Pointer(volumeMountPoint)))
1975 if r1 == 0 {
1976 err = errnoErr(e1)
1977 }
1978 return
1979 }
1980
1981 func DeviceIoControl(handle Handle, ioControlCode uint32, inBuffer *byte, inBufferSize uint32, outBuffer *byte, outBufferSize uint32, bytesReturned *uint32, overlapped *Overlapped) (err error) {
1982 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)))
1983 if r1 == 0 {
1984 err = errnoErr(e1)
1985 }
1986 return
1987 }
1988
1989 func DisconnectNamedPipe(pipe Handle) (err error) {
1990 r1, _, e1 := syscall.SyscallN(procDisconnectNamedPipe.Addr(), uintptr(pipe))
1991 if r1 == 0 {
1992 err = errnoErr(e1)
1993 }
1994 return
1995 }
1996
1997 func DuplicateHandle(hSourceProcessHandle Handle, hSourceHandle Handle, hTargetProcessHandle Handle, lpTargetHandle *Handle, dwDesiredAccess uint32, bInheritHandle bool, dwOptions uint32) (err error) {
1998 var _p0 uint32
1999 if bInheritHandle {
2000 _p0 = 1
2001 }
2002 r1, _, e1 := syscall.SyscallN(procDuplicateHandle.Addr(), uintptr(hSourceProcessHandle), uintptr(hSourceHandle), uintptr(hTargetProcessHandle), uintptr(unsafe.Pointer(lpTargetHandle)), uintptr(dwDesiredAccess), uintptr(_p0), uintptr(dwOptions))
2003 if r1 == 0 {
2004 err = errnoErr(e1)
2005 }
2006 return
2007 }
2008
2009 func EscapeCommFunction(handle Handle, dwFunc uint32) (err error) {
2010 r1, _, e1 := syscall.SyscallN(procEscapeCommFunction.Addr(), uintptr(handle), uintptr(dwFunc))
2011 if r1 == 0 {
2012 err = errnoErr(e1)
2013 }
2014 return
2015 }
2016
2017 func ExitProcess(exitcode uint32) {
2018 syscall.SyscallN(procExitProcess.Addr(), uintptr(exitcode))
2019 return
2020 }
2021
2022 func ExpandEnvironmentStrings(src *uint16, dst *uint16, size uint32) (n uint32, err error) {
2023 r0, _, e1 := syscall.SyscallN(procExpandEnvironmentStringsW.Addr(), uintptr(unsafe.Pointer(src)), uintptr(unsafe.Pointer(dst)), uintptr(size))
2024 n = uint32(r0)
2025 if n == 0 {
2026 err = errnoErr(e1)
2027 }
2028 return
2029 }
2030
2031 func FindClose(handle Handle) (err error) {
2032 r1, _, e1 := syscall.SyscallN(procFindClose.Addr(), uintptr(handle))
2033 if r1 == 0 {
2034 err = errnoErr(e1)
2035 }
2036 return
2037 }
2038
2039 func FindCloseChangeNotification(handle Handle) (err error) {
2040 r1, _, e1 := syscall.SyscallN(procFindCloseChangeNotification.Addr(), uintptr(handle))
2041 if r1 == 0 {
2042 err = errnoErr(e1)
2043 }
2044 return
2045 }
2046
2047 func FindFirstChangeNotification(path string, watchSubtree bool, notifyFilter uint32) (handle Handle, err error) {
2048 var _p0 *uint16
2049 _p0, err = syscall.UTF16PtrFromString(path)
2050 if err != nil {
2051 return
2052 }
2053 return _FindFirstChangeNotification(_p0, watchSubtree, notifyFilter)
2054 }
2055
2056 func _FindFirstChangeNotification(path *uint16, watchSubtree bool, notifyFilter uint32) (handle Handle, err error) {
2057 var _p1 uint32
2058 if watchSubtree {
2059 _p1 = 1
2060 }
2061 r0, _, e1 := syscall.SyscallN(procFindFirstChangeNotificationW.Addr(), uintptr(unsafe.Pointer(path)), uintptr(_p1), uintptr(notifyFilter))
2062 handle = Handle(r0)
2063 if handle == InvalidHandle {
2064 err = errnoErr(e1)
2065 }
2066 return
2067 }
2068
2069 func findFirstFile1(name *uint16, data *win32finddata1) (handle Handle, err error) {
2070 r0, _, e1 := syscall.SyscallN(procFindFirstFileW.Addr(), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(data)))
2071 handle = Handle(r0)
2072 if handle == InvalidHandle {
2073 err = errnoErr(e1)
2074 }
2075 return
2076 }
2077
2078 func FindFirstVolumeMountPoint(rootPathName *uint16, volumeMountPoint *uint16, bufferLength uint32) (handle Handle, err error) {
2079 r0, _, e1 := syscall.SyscallN(procFindFirstVolumeMountPointW.Addr(), uintptr(unsafe.Pointer(rootPathName)), uintptr(unsafe.Pointer(volumeMountPoint)), uintptr(bufferLength))
2080 handle = Handle(r0)
2081 if handle == InvalidHandle {
2082 err = errnoErr(e1)
2083 }
2084 return
2085 }
2086
2087 func FindFirstVolume(volumeName *uint16, bufferLength uint32) (handle Handle, err error) {
2088 r0, _, e1 := syscall.SyscallN(procFindFirstVolumeW.Addr(), uintptr(unsafe.Pointer(volumeName)), uintptr(bufferLength))
2089 handle = Handle(r0)
2090 if handle == InvalidHandle {
2091 err = errnoErr(e1)
2092 }
2093 return
2094 }
2095
2096 func FindNextChangeNotification(handle Handle) (err error) {
2097 r1, _, e1 := syscall.SyscallN(procFindNextChangeNotification.Addr(), uintptr(handle))
2098 if r1 == 0 {
2099 err = errnoErr(e1)
2100 }
2101 return
2102 }
2103
2104 func findNextFile1(handle Handle, data *win32finddata1) (err error) {
2105 r1, _, e1 := syscall.SyscallN(procFindNextFileW.Addr(), uintptr(handle), uintptr(unsafe.Pointer(data)))
2106 if r1 == 0 {
2107 err = errnoErr(e1)
2108 }
2109 return
2110 }
2111
2112 func FindNextVolumeMountPoint(findVolumeMountPoint Handle, volumeMountPoint *uint16, bufferLength uint32) (err error) {
2113 r1, _, e1 := syscall.SyscallN(procFindNextVolumeMountPointW.Addr(), uintptr(findVolumeMountPoint), uintptr(unsafe.Pointer(volumeMountPoint)), uintptr(bufferLength))
2114 if r1 == 0 {
2115 err = errnoErr(e1)
2116 }
2117 return
2118 }
2119
2120 func FindNextVolume(findVolume Handle, volumeName *uint16, bufferLength uint32) (err error) {
2121 r1, _, e1 := syscall.SyscallN(procFindNextVolumeW.Addr(), uintptr(findVolume), uintptr(unsafe.Pointer(volumeName)), uintptr(bufferLength))
2122 if r1 == 0 {
2123 err = errnoErr(e1)
2124 }
2125 return
2126 }
2127
2128 func findResource(module Handle, name uintptr, resType uintptr) (resInfo Handle, err error) {
2129 r0, _, e1 := syscall.SyscallN(procFindResourceW.Addr(), uintptr(module), uintptr(name), uintptr(resType))
2130 resInfo = Handle(r0)
2131 if resInfo == 0 {
2132 err = errnoErr(e1)
2133 }
2134 return
2135 }
2136
2137 func FindVolumeClose(findVolume Handle) (err error) {
2138 r1, _, e1 := syscall.SyscallN(procFindVolumeClose.Addr(), uintptr(findVolume))
2139 if r1 == 0 {
2140 err = errnoErr(e1)
2141 }
2142 return
2143 }
2144
2145 func FindVolumeMountPointClose(findVolumeMountPoint Handle) (err error) {
2146 r1, _, e1 := syscall.SyscallN(procFindVolumeMountPointClose.Addr(), uintptr(findVolumeMountPoint))
2147 if r1 == 0 {
2148 err = errnoErr(e1)
2149 }
2150 return
2151 }
2152
2153 func FlushConsoleInputBuffer(console Handle) (err error) {
2154 r1, _, e1 := syscall.SyscallN(procFlushConsoleInputBuffer.Addr(), uintptr(console))
2155 if r1 == 0 {
2156 err = errnoErr(e1)
2157 }
2158 return
2159 }
2160
2161 func FlushFileBuffers(handle Handle) (err error) {
2162 r1, _, e1 := syscall.SyscallN(procFlushFileBuffers.Addr(), uintptr(handle))
2163 if r1 == 0 {
2164 err = errnoErr(e1)
2165 }
2166 return
2167 }
2168
2169 func FlushViewOfFile(addr uintptr, length uintptr) (err error) {
2170 r1, _, e1 := syscall.SyscallN(procFlushViewOfFile.Addr(), uintptr(addr), uintptr(length))
2171 if r1 == 0 {
2172 err = errnoErr(e1)
2173 }
2174 return
2175 }
2176
2177 func FormatMessage(flags uint32, msgsrc uintptr, msgid uint32, langid uint32, buf []uint16, args *byte) (n uint32, err error) {
2178 var _p0 *uint16
2179 if len(buf) > 0 {
2180 _p0 = &buf[0]
2181 }
2182 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)))
2183 n = uint32(r0)
2184 if n == 0 {
2185 err = errnoErr(e1)
2186 }
2187 return
2188 }
2189
2190 func FreeEnvironmentStrings(envs *uint16) (err error) {
2191 r1, _, e1 := syscall.SyscallN(procFreeEnvironmentStringsW.Addr(), uintptr(unsafe.Pointer(envs)))
2192 if r1 == 0 {
2193 err = errnoErr(e1)
2194 }
2195 return
2196 }
2197
2198 func FreeLibrary(handle Handle) (err error) {
2199 r1, _, e1 := syscall.SyscallN(procFreeLibrary.Addr(), uintptr(handle))
2200 if r1 == 0 {
2201 err = errnoErr(e1)
2202 }
2203 return
2204 }
2205
2206 func GenerateConsoleCtrlEvent(ctrlEvent uint32, processGroupID uint32) (err error) {
2207 r1, _, e1 := syscall.SyscallN(procGenerateConsoleCtrlEvent.Addr(), uintptr(ctrlEvent), uintptr(processGroupID))
2208 if r1 == 0 {
2209 err = errnoErr(e1)
2210 }
2211 return
2212 }
2213
2214 func GetACP() (acp uint32) {
2215 r0, _, _ := syscall.SyscallN(procGetACP.Addr())
2216 acp = uint32(r0)
2217 return
2218 }
2219
2220 func GetActiveProcessorCount(groupNumber uint16) (ret uint32) {
2221 r0, _, _ := syscall.SyscallN(procGetActiveProcessorCount.Addr(), uintptr(groupNumber))
2222 ret = uint32(r0)
2223 return
2224 }
2225
2226 func GetCommModemStatus(handle Handle, lpModemStat *uint32) (err error) {
2227 r1, _, e1 := syscall.SyscallN(procGetCommModemStatus.Addr(), uintptr(handle), uintptr(unsafe.Pointer(lpModemStat)))
2228 if r1 == 0 {
2229 err = errnoErr(e1)
2230 }
2231 return
2232 }
2233
2234 func GetCommState(handle Handle, lpDCB *DCB) (err error) {
2235 r1, _, e1 := syscall.SyscallN(procGetCommState.Addr(), uintptr(handle), uintptr(unsafe.Pointer(lpDCB)))
2236 if r1 == 0 {
2237 err = errnoErr(e1)
2238 }
2239 return
2240 }
2241
2242 func GetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error) {
2243 r1, _, e1 := syscall.SyscallN(procGetCommTimeouts.Addr(), uintptr(handle), uintptr(unsafe.Pointer(timeouts)))
2244 if r1 == 0 {
2245 err = errnoErr(e1)
2246 }
2247 return
2248 }
2249
2250 func GetCommandLine() (cmd *uint16) {
2251 r0, _, _ := syscall.SyscallN(procGetCommandLineW.Addr())
2252 cmd = (*uint16)(unsafe.Pointer(r0))
2253 return
2254 }
2255
2256 func GetComputerNameEx(nametype uint32, buf *uint16, n *uint32) (err error) {
2257 r1, _, e1 := syscall.SyscallN(procGetComputerNameExW.Addr(), uintptr(nametype), uintptr(unsafe.Pointer(buf)), uintptr(unsafe.Pointer(n)))
2258 if r1 == 0 {
2259 err = errnoErr(e1)
2260 }
2261 return
2262 }
2263
2264 func GetComputerName(buf *uint16, n *uint32) (err error) {
2265 r1, _, e1 := syscall.SyscallN(procGetComputerNameW.Addr(), uintptr(unsafe.Pointer(buf)), uintptr(unsafe.Pointer(n)))
2266 if r1 == 0 {
2267 err = errnoErr(e1)
2268 }
2269 return
2270 }
2271
2272 func GetConsoleCP() (cp uint32, err error) {
2273 r0, _, e1 := syscall.SyscallN(procGetConsoleCP.Addr())
2274 cp = uint32(r0)
2275 if cp == 0 {
2276 err = errnoErr(e1)
2277 }
2278 return
2279 }
2280
2281 func GetConsoleMode(console Handle, mode *uint32) (err error) {
2282 r1, _, e1 := syscall.SyscallN(procGetConsoleMode.Addr(), uintptr(console), uintptr(unsafe.Pointer(mode)))
2283 if r1 == 0 {
2284 err = errnoErr(e1)
2285 }
2286 return
2287 }
2288
2289 func GetConsoleOutputCP() (cp uint32, err error) {
2290 r0, _, e1 := syscall.SyscallN(procGetConsoleOutputCP.Addr())
2291 cp = uint32(r0)
2292 if cp == 0 {
2293 err = errnoErr(e1)
2294 }
2295 return
2296 }
2297
2298 func GetConsoleScreenBufferInfo(console Handle, info *ConsoleScreenBufferInfo) (err error) {
2299 r1, _, e1 := syscall.SyscallN(procGetConsoleScreenBufferInfo.Addr(), uintptr(console), uintptr(unsafe.Pointer(info)))
2300 if r1 == 0 {
2301 err = errnoErr(e1)
2302 }
2303 return
2304 }
2305
2306 func GetCurrentDirectory(buflen uint32, buf *uint16) (n uint32, err error) {
2307 r0, _, e1 := syscall.SyscallN(procGetCurrentDirectoryW.Addr(), uintptr(buflen), uintptr(unsafe.Pointer(buf)))
2308 n = uint32(r0)
2309 if n == 0 {
2310 err = errnoErr(e1)
2311 }
2312 return
2313 }
2314
2315 func GetCurrentProcessId() (pid uint32) {
2316 r0, _, _ := syscall.SyscallN(procGetCurrentProcessId.Addr())
2317 pid = uint32(r0)
2318 return
2319 }
2320
2321 func GetCurrentThreadId() (id uint32) {
2322 r0, _, _ := syscall.SyscallN(procGetCurrentThreadId.Addr())
2323 id = uint32(r0)
2324 return
2325 }
2326
2327 func GetDiskFreeSpaceEx(directoryName *uint16, freeBytesAvailableToCaller *uint64, totalNumberOfBytes *uint64, totalNumberOfFreeBytes *uint64) (err error) {
2328 r1, _, e1 := syscall.SyscallN(procGetDiskFreeSpaceExW.Addr(), uintptr(unsafe.Pointer(directoryName)), uintptr(unsafe.Pointer(freeBytesAvailableToCaller)), uintptr(unsafe.Pointer(totalNumberOfBytes)), uintptr(unsafe.Pointer(totalNumberOfFreeBytes)))
2329 if r1 == 0 {
2330 err = errnoErr(e1)
2331 }
2332 return
2333 }
2334
2335 func GetDriveType(rootPathName *uint16) (driveType uint32) {
2336 r0, _, _ := syscall.SyscallN(procGetDriveTypeW.Addr(), uintptr(unsafe.Pointer(rootPathName)))
2337 driveType = uint32(r0)
2338 return
2339 }
2340
2341 func GetEnvironmentStrings() (envs *uint16, err error) {
2342 r0, _, e1 := syscall.SyscallN(procGetEnvironmentStringsW.Addr())
2343 envs = (*uint16)(unsafe.Pointer(r0))
2344 if envs == nil {
2345 err = errnoErr(e1)
2346 }
2347 return
2348 }
2349
2350 func GetEnvironmentVariable(name *uint16, buffer *uint16, size uint32) (n uint32, err error) {
2351 r0, _, e1 := syscall.SyscallN(procGetEnvironmentVariableW.Addr(), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(buffer)), uintptr(size))
2352 n = uint32(r0)
2353 if n == 0 {
2354 err = errnoErr(e1)
2355 }
2356 return
2357 }
2358
2359 func GetExitCodeProcess(handle Handle, exitcode *uint32) (err error) {
2360 r1, _, e1 := syscall.SyscallN(procGetExitCodeProcess.Addr(), uintptr(handle), uintptr(unsafe.Pointer(exitcode)))
2361 if r1 == 0 {
2362 err = errnoErr(e1)
2363 }
2364 return
2365 }
2366
2367 func GetFileAttributesEx(name *uint16, level uint32, info *byte) (err error) {
2368 r1, _, e1 := syscall.SyscallN(procGetFileAttributesExW.Addr(), uintptr(unsafe.Pointer(name)), uintptr(level), uintptr(unsafe.Pointer(info)))
2369 if r1 == 0 {
2370 err = errnoErr(e1)
2371 }
2372 return
2373 }
2374
2375 func GetFileAttributes(name *uint16) (attrs uint32, err error) {
2376 r0, _, e1 := syscall.SyscallN(procGetFileAttributesW.Addr(), uintptr(unsafe.Pointer(name)))
2377 attrs = uint32(r0)
2378 if attrs == INVALID_FILE_ATTRIBUTES {
2379 err = errnoErr(e1)
2380 }
2381 return
2382 }
2383
2384 func GetFileInformationByHandle(handle Handle, data *ByHandleFileInformation) (err error) {
2385 r1, _, e1 := syscall.SyscallN(procGetFileInformationByHandle.Addr(), uintptr(handle), uintptr(unsafe.Pointer(data)))
2386 if r1 == 0 {
2387 err = errnoErr(e1)
2388 }
2389 return
2390 }
2391
2392 func GetFileInformationByHandleEx(handle Handle, class uint32, outBuffer *byte, outBufferLen uint32) (err error) {
2393 r1, _, e1 := syscall.SyscallN(procGetFileInformationByHandleEx.Addr(), uintptr(handle), uintptr(class), uintptr(unsafe.Pointer(outBuffer)), uintptr(outBufferLen))
2394 if r1 == 0 {
2395 err = errnoErr(e1)
2396 }
2397 return
2398 }
2399
2400 func GetFileTime(handle Handle, ctime *Filetime, atime *Filetime, wtime *Filetime) (err error) {
2401 r1, _, e1 := syscall.SyscallN(procGetFileTime.Addr(), uintptr(handle), uintptr(unsafe.Pointer(ctime)), uintptr(unsafe.Pointer(atime)), uintptr(unsafe.Pointer(wtime)))
2402 if r1 == 0 {
2403 err = errnoErr(e1)
2404 }
2405 return
2406 }
2407
2408 func GetFileType(filehandle Handle) (n uint32, err error) {
2409 r0, _, e1 := syscall.SyscallN(procGetFileType.Addr(), uintptr(filehandle))
2410 n = uint32(r0)
2411 if n == 0 {
2412 err = errnoErr(e1)
2413 }
2414 return
2415 }
2416
2417 func GetFinalPathNameByHandle(file Handle, filePath *uint16, filePathSize uint32, flags uint32) (n uint32, err error) {
2418 r0, _, e1 := syscall.SyscallN(procGetFinalPathNameByHandleW.Addr(), uintptr(file), uintptr(unsafe.Pointer(filePath)), uintptr(filePathSize), uintptr(flags))
2419 n = uint32(r0)
2420 if n == 0 {
2421 err = errnoErr(e1)
2422 }
2423 return
2424 }
2425
2426 func GetFullPathName(path *uint16, buflen uint32, buf *uint16, fname **uint16) (n uint32, err error) {
2427 r0, _, e1 := syscall.SyscallN(procGetFullPathNameW.Addr(), uintptr(unsafe.Pointer(path)), uintptr(buflen), uintptr(unsafe.Pointer(buf)), uintptr(unsafe.Pointer(fname)))
2428 n = uint32(r0)
2429 if n == 0 {
2430 err = errnoErr(e1)
2431 }
2432 return
2433 }
2434
2435 func GetLargePageMinimum() (size uintptr) {
2436 r0, _, _ := syscall.SyscallN(procGetLargePageMinimum.Addr())
2437 size = uintptr(r0)
2438 return
2439 }
2440
2441 func GetLastError() (lasterr error) {
2442 r0, _, _ := syscall.SyscallN(procGetLastError.Addr())
2443 if r0 != 0 {
2444 lasterr = syscall.Errno(r0)
2445 }
2446 return
2447 }
2448
2449 func GetLogicalDriveStrings(bufferLength uint32, buffer *uint16) (n uint32, err error) {
2450 r0, _, e1 := syscall.SyscallN(procGetLogicalDriveStringsW.Addr(), uintptr(bufferLength), uintptr(unsafe.Pointer(buffer)))
2451 n = uint32(r0)
2452 if n == 0 {
2453 err = errnoErr(e1)
2454 }
2455 return
2456 }
2457
2458 func GetLogicalDrives() (drivesBitMask uint32, err error) {
2459 r0, _, e1 := syscall.SyscallN(procGetLogicalDrives.Addr())
2460 drivesBitMask = uint32(r0)
2461 if drivesBitMask == 0 {
2462 err = errnoErr(e1)
2463 }
2464 return
2465 }
2466
2467 func GetLongPathName(path *uint16, buf *uint16, buflen uint32) (n uint32, err error) {
2468 r0, _, e1 := syscall.SyscallN(procGetLongPathNameW.Addr(), uintptr(unsafe.Pointer(path)), uintptr(unsafe.Pointer(buf)), uintptr(buflen))
2469 n = uint32(r0)
2470 if n == 0 {
2471 err = errnoErr(e1)
2472 }
2473 return
2474 }
2475
2476 func GetMaximumProcessorCount(groupNumber uint16) (ret uint32) {
2477 r0, _, _ := syscall.SyscallN(procGetMaximumProcessorCount.Addr(), uintptr(groupNumber))
2478 ret = uint32(r0)
2479 return
2480 }
2481
2482 func GetModuleFileName(module Handle, filename *uint16, size uint32) (n uint32, err error) {
2483 r0, _, e1 := syscall.SyscallN(procGetModuleFileNameW.Addr(), uintptr(module), uintptr(unsafe.Pointer(filename)), uintptr(size))
2484 n = uint32(r0)
2485 if n == 0 {
2486 err = errnoErr(e1)
2487 }
2488 return
2489 }
2490
2491 func GetModuleHandleEx(flags uint32, moduleName *uint16, module *Handle) (err error) {
2492 r1, _, e1 := syscall.SyscallN(procGetModuleHandleExW.Addr(), uintptr(flags), uintptr(unsafe.Pointer(moduleName)), uintptr(unsafe.Pointer(module)))
2493 if r1 == 0 {
2494 err = errnoErr(e1)
2495 }
2496 return
2497 }
2498
2499 func GetNamedPipeClientProcessId(pipe Handle, clientProcessID *uint32) (err error) {
2500 r1, _, e1 := syscall.SyscallN(procGetNamedPipeClientProcessId.Addr(), uintptr(pipe), uintptr(unsafe.Pointer(clientProcessID)))
2501 if r1 == 0 {
2502 err = errnoErr(e1)
2503 }
2504 return
2505 }
2506
2507 func GetNamedPipeHandleState(pipe Handle, state *uint32, curInstances *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32, userName *uint16, maxUserNameSize uint32) (err error) {
2508 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))
2509 if r1 == 0 {
2510 err = errnoErr(e1)
2511 }
2512 return
2513 }
2514
2515 func GetNamedPipeInfo(pipe Handle, flags *uint32, outSize *uint32, inSize *uint32, maxInstances *uint32) (err error) {
2516 r1, _, e1 := syscall.SyscallN(procGetNamedPipeInfo.Addr(), uintptr(pipe), uintptr(unsafe.Pointer(flags)), uintptr(unsafe.Pointer(outSize)), uintptr(unsafe.Pointer(inSize)), uintptr(unsafe.Pointer(maxInstances)))
2517 if r1 == 0 {
2518 err = errnoErr(e1)
2519 }
2520 return
2521 }
2522
2523 func GetNamedPipeServerProcessId(pipe Handle, serverProcessID *uint32) (err error) {
2524 r1, _, e1 := syscall.SyscallN(procGetNamedPipeServerProcessId.Addr(), uintptr(pipe), uintptr(unsafe.Pointer(serverProcessID)))
2525 if r1 == 0 {
2526 err = errnoErr(e1)
2527 }
2528 return
2529 }
2530
2531 func GetNumberOfConsoleInputEvents(console Handle, numevents *uint32) (err error) {
2532 r1, _, e1 := syscall.SyscallN(procGetNumberOfConsoleInputEvents.Addr(), uintptr(console), uintptr(unsafe.Pointer(numevents)))
2533 if r1 == 0 {
2534 err = errnoErr(e1)
2535 }
2536 return
2537 }
2538
2539 func GetOverlappedResult(handle Handle, overlapped *Overlapped, done *uint32, wait bool) (err error) {
2540 var _p0 uint32
2541 if wait {
2542 _p0 = 1
2543 }
2544 r1, _, e1 := syscall.SyscallN(procGetOverlappedResult.Addr(), uintptr(handle), uintptr(unsafe.Pointer(overlapped)), uintptr(unsafe.Pointer(done)), uintptr(_p0))
2545 if r1 == 0 {
2546 err = errnoErr(e1)
2547 }
2548 return
2549 }
2550
2551 func GetPriorityClass(process Handle) (ret uint32, err error) {
2552 r0, _, e1 := syscall.SyscallN(procGetPriorityClass.Addr(), uintptr(process))
2553 ret = uint32(r0)
2554 if ret == 0 {
2555 err = errnoErr(e1)
2556 }
2557 return
2558 }
2559
2560 func GetProcAddress(module Handle, procname string) (proc uintptr, err error) {
2561 var _p0 *byte
2562 _p0, err = syscall.BytePtrFromString(procname)
2563 if err != nil {
2564 return
2565 }
2566 return _GetProcAddress(module, _p0)
2567 }
2568
2569 func _GetProcAddress(module Handle, procname *byte) (proc uintptr, err error) {
2570 r0, _, e1 := syscall.SyscallN(procGetProcAddress.Addr(), uintptr(module), uintptr(unsafe.Pointer(procname)))
2571 proc = uintptr(r0)
2572 if proc == 0 {
2573 err = errnoErr(e1)
2574 }
2575 return
2576 }
2577
2578 func GetProcessId(process Handle) (id uint32, err error) {
2579 r0, _, e1 := syscall.SyscallN(procGetProcessId.Addr(), uintptr(process))
2580 id = uint32(r0)
2581 if id == 0 {
2582 err = errnoErr(e1)
2583 }
2584 return
2585 }
2586
2587 func getProcessPreferredUILanguages(flags uint32, numLanguages *uint32, buf *uint16, bufSize *uint32) (err error) {
2588 r1, _, e1 := syscall.SyscallN(procGetProcessPreferredUILanguages.Addr(), uintptr(flags), uintptr(unsafe.Pointer(numLanguages)), uintptr(unsafe.Pointer(buf)), uintptr(unsafe.Pointer(bufSize)))
2589 if r1 == 0 {
2590 err = errnoErr(e1)
2591 }
2592 return
2593 }
2594
2595 func GetProcessShutdownParameters(level *uint32, flags *uint32) (err error) {
2596 r1, _, e1 := syscall.SyscallN(procGetProcessShutdownParameters.Addr(), uintptr(unsafe.Pointer(level)), uintptr(unsafe.Pointer(flags)))
2597 if r1 == 0 {
2598 err = errnoErr(e1)
2599 }
2600 return
2601 }
2602
2603 func GetProcessTimes(handle Handle, creationTime *Filetime, exitTime *Filetime, kernelTime *Filetime, userTime *Filetime) (err error) {
2604 r1, _, e1 := syscall.SyscallN(procGetProcessTimes.Addr(), uintptr(handle), uintptr(unsafe.Pointer(creationTime)), uintptr(unsafe.Pointer(exitTime)), uintptr(unsafe.Pointer(kernelTime)), uintptr(unsafe.Pointer(userTime)))
2605 if r1 == 0 {
2606 err = errnoErr(e1)
2607 }
2608 return
2609 }
2610
2611 func GetProcessWorkingSetSizeEx(hProcess Handle, lpMinimumWorkingSetSize *uintptr, lpMaximumWorkingSetSize *uintptr, flags *uint32) {
2612 syscall.SyscallN(procGetProcessWorkingSetSizeEx.Addr(), uintptr(hProcess), uintptr(unsafe.Pointer(lpMinimumWorkingSetSize)), uintptr(unsafe.Pointer(lpMaximumWorkingSetSize)), uintptr(unsafe.Pointer(flags)))
2613 return
2614 }
2615
2616 func GetQueuedCompletionStatus(cphandle Handle, qty *uint32, key *uintptr, overlapped **Overlapped, timeout uint32) (err error) {
2617 r1, _, e1 := syscall.SyscallN(procGetQueuedCompletionStatus.Addr(), uintptr(cphandle), uintptr(unsafe.Pointer(qty)), uintptr(unsafe.Pointer(key)), uintptr(unsafe.Pointer(overlapped)), uintptr(timeout))
2618 if r1 == 0 {
2619 err = errnoErr(e1)
2620 }
2621 return
2622 }
2623
2624 func GetShortPathName(longpath *uint16, shortpath *uint16, buflen uint32) (n uint32, err error) {
2625 r0, _, e1 := syscall.SyscallN(procGetShortPathNameW.Addr(), uintptr(unsafe.Pointer(longpath)), uintptr(unsafe.Pointer(shortpath)), uintptr(buflen))
2626 n = uint32(r0)
2627 if n == 0 {
2628 err = errnoErr(e1)
2629 }
2630 return
2631 }
2632
2633 func getStartupInfo(startupInfo *StartupInfo) {
2634 syscall.SyscallN(procGetStartupInfoW.Addr(), uintptr(unsafe.Pointer(startupInfo)))
2635 return
2636 }
2637
2638 func GetStdHandle(stdhandle uint32) (handle Handle, err error) {
2639 r0, _, e1 := syscall.SyscallN(procGetStdHandle.Addr(), uintptr(stdhandle))
2640 handle = Handle(r0)
2641 if handle == InvalidHandle {
2642 err = errnoErr(e1)
2643 }
2644 return
2645 }
2646
2647 func getSystemDirectory(dir *uint16, dirLen uint32) (len uint32, err error) {
2648 r0, _, e1 := syscall.SyscallN(procGetSystemDirectoryW.Addr(), uintptr(unsafe.Pointer(dir)), uintptr(dirLen))
2649 len = uint32(r0)
2650 if len == 0 {
2651 err = errnoErr(e1)
2652 }
2653 return
2654 }
2655
2656 func getSystemPreferredUILanguages(flags uint32, numLanguages *uint32, buf *uint16, bufSize *uint32) (err error) {
2657 r1, _, e1 := syscall.SyscallN(procGetSystemPreferredUILanguages.Addr(), uintptr(flags), uintptr(unsafe.Pointer(numLanguages)), uintptr(unsafe.Pointer(buf)), uintptr(unsafe.Pointer(bufSize)))
2658 if r1 == 0 {
2659 err = errnoErr(e1)
2660 }
2661 return
2662 }
2663
2664 func GetSystemTimeAsFileTime(time *Filetime) {
2665 syscall.SyscallN(procGetSystemTimeAsFileTime.Addr(), uintptr(unsafe.Pointer(time)))
2666 return
2667 }
2668
2669 func GetSystemTimePreciseAsFileTime(time *Filetime) {
2670 syscall.SyscallN(procGetSystemTimePreciseAsFileTime.Addr(), uintptr(unsafe.Pointer(time)))
2671 return
2672 }
2673
2674 func getSystemWindowsDirectory(dir *uint16, dirLen uint32) (len uint32, err error) {
2675 r0, _, e1 := syscall.SyscallN(procGetSystemWindowsDirectoryW.Addr(), uintptr(unsafe.Pointer(dir)), uintptr(dirLen))
2676 len = uint32(r0)
2677 if len == 0 {
2678 err = errnoErr(e1)
2679 }
2680 return
2681 }
2682
2683 func GetTempPath(buflen uint32, buf *uint16) (n uint32, err error) {
2684 r0, _, e1 := syscall.SyscallN(procGetTempPathW.Addr(), uintptr(buflen), uintptr(unsafe.Pointer(buf)))
2685 n = uint32(r0)
2686 if n == 0 {
2687 err = errnoErr(e1)
2688 }
2689 return
2690 }
2691
2692 func getThreadPreferredUILanguages(flags uint32, numLanguages *uint32, buf *uint16, bufSize *uint32) (err error) {
2693 r1, _, e1 := syscall.SyscallN(procGetThreadPreferredUILanguages.Addr(), uintptr(flags), uintptr(unsafe.Pointer(numLanguages)), uintptr(unsafe.Pointer(buf)), uintptr(unsafe.Pointer(bufSize)))
2694 if r1 == 0 {
2695 err = errnoErr(e1)
2696 }
2697 return
2698 }
2699
2700 func getTickCount64() (ms uint64) {
2701 r0, _, _ := syscall.SyscallN(procGetTickCount64.Addr())
2702 ms = uint64(r0)
2703 return
2704 }
2705
2706 func GetTimeZoneInformation(tzi *Timezoneinformation) (rc uint32, err error) {
2707 r0, _, e1 := syscall.SyscallN(procGetTimeZoneInformation.Addr(), uintptr(unsafe.Pointer(tzi)))
2708 rc = uint32(r0)
2709 if rc == 0xffffffff {
2710 err = errnoErr(e1)
2711 }
2712 return
2713 }
2714
2715 func getUserPreferredUILanguages(flags uint32, numLanguages *uint32, buf *uint16, bufSize *uint32) (err error) {
2716 r1, _, e1 := syscall.SyscallN(procGetUserPreferredUILanguages.Addr(), uintptr(flags), uintptr(unsafe.Pointer(numLanguages)), uintptr(unsafe.Pointer(buf)), uintptr(unsafe.Pointer(bufSize)))
2717 if r1 == 0 {
2718 err = errnoErr(e1)
2719 }
2720 return
2721 }
2722
2723 func GetVersion() (ver uint32, err error) {
2724 r0, _, e1 := syscall.SyscallN(procGetVersion.Addr())
2725 ver = uint32(r0)
2726 if ver == 0 {
2727 err = errnoErr(e1)
2728 }
2729 return
2730 }
2731
2732 func GetVolumeInformationByHandle(file Handle, volumeNameBuffer *uint16, volumeNameSize uint32, volumeNameSerialNumber *uint32, maximumComponentLength *uint32, fileSystemFlags *uint32, fileSystemNameBuffer *uint16, fileSystemNameSize uint32) (err error) {
2733 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))
2734 if r1 == 0 {
2735 err = errnoErr(e1)
2736 }
2737 return
2738 }
2739
2740 func GetVolumeInformation(rootPathName *uint16, volumeNameBuffer *uint16, volumeNameSize uint32, volumeNameSerialNumber *uint32, maximumComponentLength *uint32, fileSystemFlags *uint32, fileSystemNameBuffer *uint16, fileSystemNameSize uint32) (err error) {
2741 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))
2742 if r1 == 0 {
2743 err = errnoErr(e1)
2744 }
2745 return
2746 }
2747
2748 func GetVolumeNameForVolumeMountPoint(volumeMountPoint *uint16, volumeName *uint16, bufferlength uint32) (err error) {
2749 r1, _, e1 := syscall.SyscallN(procGetVolumeNameForVolumeMountPointW.Addr(), uintptr(unsafe.Pointer(volumeMountPoint)), uintptr(unsafe.Pointer(volumeName)), uintptr(bufferlength))
2750 if r1 == 0 {
2751 err = errnoErr(e1)
2752 }
2753 return
2754 }
2755
2756 func GetVolumePathName(fileName *uint16, volumePathName *uint16, bufferLength uint32) (err error) {
2757 r1, _, e1 := syscall.SyscallN(procGetVolumePathNameW.Addr(), uintptr(unsafe.Pointer(fileName)), uintptr(unsafe.Pointer(volumePathName)), uintptr(bufferLength))
2758 if r1 == 0 {
2759 err = errnoErr(e1)
2760 }
2761 return
2762 }
2763
2764 func GetVolumePathNamesForVolumeName(volumeName *uint16, volumePathNames *uint16, bufferLength uint32, returnLength *uint32) (err error) {
2765 r1, _, e1 := syscall.SyscallN(procGetVolumePathNamesForVolumeNameW.Addr(), uintptr(unsafe.Pointer(volumeName)), uintptr(unsafe.Pointer(volumePathNames)), uintptr(bufferLength), uintptr(unsafe.Pointer(returnLength)))
2766 if r1 == 0 {
2767 err = errnoErr(e1)
2768 }
2769 return
2770 }
2771
2772 func getWindowsDirectory(dir *uint16, dirLen uint32) (len uint32, err error) {
2773 r0, _, e1 := syscall.SyscallN(procGetWindowsDirectoryW.Addr(), uintptr(unsafe.Pointer(dir)), uintptr(dirLen))
2774 len = uint32(r0)
2775 if len == 0 {
2776 err = errnoErr(e1)
2777 }
2778 return
2779 }
2780
2781 func initializeProcThreadAttributeList(attrlist *ProcThreadAttributeList, attrcount uint32, flags uint32, size *uintptr) (err error) {
2782 r1, _, e1 := syscall.SyscallN(procInitializeProcThreadAttributeList.Addr(), uintptr(unsafe.Pointer(attrlist)), uintptr(attrcount), uintptr(flags), uintptr(unsafe.Pointer(size)))
2783 if r1 == 0 {
2784 err = errnoErr(e1)
2785 }
2786 return
2787 }
2788
2789 func IsWow64Process(handle Handle, isWow64 *bool) (err error) {
2790 var _p0 uint32
2791 if *isWow64 {
2792 _p0 = 1
2793 }
2794 r1, _, e1 := syscall.SyscallN(procIsWow64Process.Addr(), uintptr(handle), uintptr(unsafe.Pointer(&_p0)))
2795 *isWow64 = _p0 != 0
2796 if r1 == 0 {
2797 err = errnoErr(e1)
2798 }
2799 return
2800 }
2801
2802 func IsWow64Process2(handle Handle, processMachine *uint16, nativeMachine *uint16) (err error) {
2803 err = procIsWow64Process2.Find()
2804 if err != nil {
2805 return
2806 }
2807 r1, _, e1 := syscall.SyscallN(procIsWow64Process2.Addr(), uintptr(handle), uintptr(unsafe.Pointer(processMachine)), uintptr(unsafe.Pointer(nativeMachine)))
2808 if r1 == 0 {
2809 err = errnoErr(e1)
2810 }
2811 return
2812 }
2813
2814 func LoadLibraryEx(libname string, zero Handle, flags uintptr) (handle Handle, err error) {
2815 var _p0 *uint16
2816 _p0, err = syscall.UTF16PtrFromString(libname)
2817 if err != nil {
2818 return
2819 }
2820 return _LoadLibraryEx(_p0, zero, flags)
2821 }
2822
2823 func _LoadLibraryEx(libname *uint16, zero Handle, flags uintptr) (handle Handle, err error) {
2824 r0, _, e1 := syscall.SyscallN(procLoadLibraryExW.Addr(), uintptr(unsafe.Pointer(libname)), uintptr(zero), uintptr(flags))
2825 handle = Handle(r0)
2826 if handle == 0 {
2827 err = errnoErr(e1)
2828 }
2829 return
2830 }
2831
2832 func LoadLibrary(libname string) (handle Handle, err error) {
2833 var _p0 *uint16
2834 _p0, err = syscall.UTF16PtrFromString(libname)
2835 if err != nil {
2836 return
2837 }
2838 return _LoadLibrary(_p0)
2839 }
2840
2841 func _LoadLibrary(libname *uint16) (handle Handle, err error) {
2842 r0, _, e1 := syscall.SyscallN(procLoadLibraryW.Addr(), uintptr(unsafe.Pointer(libname)))
2843 handle = Handle(r0)
2844 if handle == 0 {
2845 err = errnoErr(e1)
2846 }
2847 return
2848 }
2849
2850 func LoadResource(module Handle, resInfo Handle) (resData Handle, err error) {
2851 r0, _, e1 := syscall.SyscallN(procLoadResource.Addr(), uintptr(module), uintptr(resInfo))
2852 resData = Handle(r0)
2853 if resData == 0 {
2854 err = errnoErr(e1)
2855 }
2856 return
2857 }
2858
2859 func LocalAlloc(flags uint32, length uint32) (ptr uintptr, err error) {
2860 r0, _, e1 := syscall.SyscallN(procLocalAlloc.Addr(), uintptr(flags), uintptr(length))
2861 ptr = uintptr(r0)
2862 if ptr == 0 {
2863 err = errnoErr(e1)
2864 }
2865 return
2866 }
2867
2868 func LocalFree(hmem Handle) (handle Handle, err error) {
2869 r0, _, e1 := syscall.SyscallN(procLocalFree.Addr(), uintptr(hmem))
2870 handle = Handle(r0)
2871 if handle != 0 {
2872 err = errnoErr(e1)
2873 }
2874 return
2875 }
2876
2877 func LockFileEx(file Handle, flags uint32, reserved uint32, bytesLow uint32, bytesHigh uint32, overlapped *Overlapped) (err error) {
2878 r1, _, e1 := syscall.SyscallN(procLockFileEx.Addr(), uintptr(file), uintptr(flags), uintptr(reserved), uintptr(bytesLow), uintptr(bytesHigh), uintptr(unsafe.Pointer(overlapped)))
2879 if r1 == 0 {
2880 err = errnoErr(e1)
2881 }
2882 return
2883 }
2884
2885 func LockResource(resData Handle) (addr uintptr, err error) {
2886 r0, _, e1 := syscall.SyscallN(procLockResource.Addr(), uintptr(resData))
2887 addr = uintptr(r0)
2888 if addr == 0 {
2889 err = errnoErr(e1)
2890 }
2891 return
2892 }
2893
2894 func MapViewOfFile(handle Handle, access uint32, offsetHigh uint32, offsetLow uint32, length uintptr) (addr uintptr, err error) {
2895 r0, _, e1 := syscall.SyscallN(procMapViewOfFile.Addr(), uintptr(handle), uintptr(access), uintptr(offsetHigh), uintptr(offsetLow), uintptr(length))
2896 addr = uintptr(r0)
2897 if addr == 0 {
2898 err = errnoErr(e1)
2899 }
2900 return
2901 }
2902
2903 func Module32First(snapshot Handle, moduleEntry *ModuleEntry32) (err error) {
2904 r1, _, e1 := syscall.SyscallN(procModule32FirstW.Addr(), uintptr(snapshot), uintptr(unsafe.Pointer(moduleEntry)))
2905 if r1 == 0 {
2906 err = errnoErr(e1)
2907 }
2908 return
2909 }
2910
2911 func Module32Next(snapshot Handle, moduleEntry *ModuleEntry32) (err error) {
2912 r1, _, e1 := syscall.SyscallN(procModule32NextW.Addr(), uintptr(snapshot), uintptr(unsafe.Pointer(moduleEntry)))
2913 if r1 == 0 {
2914 err = errnoErr(e1)
2915 }
2916 return
2917 }
2918
2919 func MoveFileEx(from *uint16, to *uint16, flags uint32) (err error) {
2920 r1, _, e1 := syscall.SyscallN(procMoveFileExW.Addr(), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(to)), uintptr(flags))
2921 if r1 == 0 {
2922 err = errnoErr(e1)
2923 }
2924 return
2925 }
2926
2927 func MoveFile(from *uint16, to *uint16) (err error) {
2928 r1, _, e1 := syscall.SyscallN(procMoveFileW.Addr(), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(to)))
2929 if r1 == 0 {
2930 err = errnoErr(e1)
2931 }
2932 return
2933 }
2934
2935 func MultiByteToWideChar(codePage uint32, dwFlags uint32, str *byte, nstr int32, wchar *uint16, nwchar int32) (nwrite int32, err error) {
2936 r0, _, e1 := syscall.SyscallN(procMultiByteToWideChar.Addr(), uintptr(codePage), uintptr(dwFlags), uintptr(unsafe.Pointer(str)), uintptr(nstr), uintptr(unsafe.Pointer(wchar)), uintptr(nwchar))
2937 nwrite = int32(r0)
2938 if nwrite == 0 {
2939 err = errnoErr(e1)
2940 }
2941 return
2942 }
2943
2944 func OpenEvent(desiredAccess uint32, inheritHandle bool, name *uint16) (handle Handle, err error) {
2945 var _p0 uint32
2946 if inheritHandle {
2947 _p0 = 1
2948 }
2949 r0, _, e1 := syscall.SyscallN(procOpenEventW.Addr(), uintptr(desiredAccess), uintptr(_p0), uintptr(unsafe.Pointer(name)))
2950 handle = Handle(r0)
2951 if handle == 0 {
2952 err = errnoErr(e1)
2953 }
2954 return
2955 }
2956
2957 func OpenMutex(desiredAccess uint32, inheritHandle bool, name *uint16) (handle Handle, err error) {
2958 var _p0 uint32
2959 if inheritHandle {
2960 _p0 = 1
2961 }
2962 r0, _, e1 := syscall.SyscallN(procOpenMutexW.Addr(), uintptr(desiredAccess), uintptr(_p0), uintptr(unsafe.Pointer(name)))
2963 handle = Handle(r0)
2964 if handle == 0 {
2965 err = errnoErr(e1)
2966 }
2967 return
2968 }
2969
2970 func OpenProcess(desiredAccess uint32, inheritHandle bool, processId uint32) (handle Handle, err error) {
2971 var _p0 uint32
2972 if inheritHandle {
2973 _p0 = 1
2974 }
2975 r0, _, e1 := syscall.SyscallN(procOpenProcess.Addr(), uintptr(desiredAccess), uintptr(_p0), uintptr(processId))
2976 handle = Handle(r0)
2977 if handle == 0 {
2978 err = errnoErr(e1)
2979 }
2980 return
2981 }
2982
2983 func OpenThread(desiredAccess uint32, inheritHandle bool, threadId uint32) (handle Handle, err error) {
2984 var _p0 uint32
2985 if inheritHandle {
2986 _p0 = 1
2987 }
2988 r0, _, e1 := syscall.SyscallN(procOpenThread.Addr(), uintptr(desiredAccess), uintptr(_p0), uintptr(threadId))
2989 handle = Handle(r0)
2990 if handle == 0 {
2991 err = errnoErr(e1)
2992 }
2993 return
2994 }
2995
2996 func PostQueuedCompletionStatus(cphandle Handle, qty uint32, key uintptr, overlapped *Overlapped) (err error) {
2997 r1, _, e1 := syscall.SyscallN(procPostQueuedCompletionStatus.Addr(), uintptr(cphandle), uintptr(qty), uintptr(key), uintptr(unsafe.Pointer(overlapped)))
2998 if r1 == 0 {
2999 err = errnoErr(e1)
3000 }
3001 return
3002 }
3003
3004 func Process32First(snapshot Handle, procEntry *ProcessEntry32) (err error) {
3005 r1, _, e1 := syscall.SyscallN(procProcess32FirstW.Addr(), uintptr(snapshot), uintptr(unsafe.Pointer(procEntry)))
3006 if r1 == 0 {
3007 err = errnoErr(e1)
3008 }
3009 return
3010 }
3011
3012 func Process32Next(snapshot Handle, procEntry *ProcessEntry32) (err error) {
3013 r1, _, e1 := syscall.SyscallN(procProcess32NextW.Addr(), uintptr(snapshot), uintptr(unsafe.Pointer(procEntry)))
3014 if r1 == 0 {
3015 err = errnoErr(e1)
3016 }
3017 return
3018 }
3019
3020 func ProcessIdToSessionId(pid uint32, sessionid *uint32) (err error) {
3021 r1, _, e1 := syscall.SyscallN(procProcessIdToSessionId.Addr(), uintptr(pid), uintptr(unsafe.Pointer(sessionid)))
3022 if r1 == 0 {
3023 err = errnoErr(e1)
3024 }
3025 return
3026 }
3027
3028 func PulseEvent(event Handle) (err error) {
3029 r1, _, e1 := syscall.SyscallN(procPulseEvent.Addr(), uintptr(event))
3030 if r1 == 0 {
3031 err = errnoErr(e1)
3032 }
3033 return
3034 }
3035
3036 func PurgeComm(handle Handle, dwFlags uint32) (err error) {
3037 r1, _, e1 := syscall.SyscallN(procPurgeComm.Addr(), uintptr(handle), uintptr(dwFlags))
3038 if r1 == 0 {
3039 err = errnoErr(e1)
3040 }
3041 return
3042 }
3043
3044 func QueryDosDevice(deviceName *uint16, targetPath *uint16, max uint32) (n uint32, err error) {
3045 r0, _, e1 := syscall.SyscallN(procQueryDosDeviceW.Addr(), uintptr(unsafe.Pointer(deviceName)), uintptr(unsafe.Pointer(targetPath)), uintptr(max))
3046 n = uint32(r0)
3047 if n == 0 {
3048 err = errnoErr(e1)
3049 }
3050 return
3051 }
3052
3053 func QueryFullProcessImageName(proc Handle, flags uint32, exeName *uint16, size *uint32) (err error) {
3054 r1, _, e1 := syscall.SyscallN(procQueryFullProcessImageNameW.Addr(), uintptr(proc), uintptr(flags), uintptr(unsafe.Pointer(exeName)), uintptr(unsafe.Pointer(size)))
3055 if r1 == 0 {
3056 err = errnoErr(e1)
3057 }
3058 return
3059 }
3060
3061 func QueryInformationJobObject(job Handle, JobObjectInformationClass int32, JobObjectInformation uintptr, JobObjectInformationLength uint32, retlen *uint32) (err error) {
3062 r1, _, e1 := syscall.SyscallN(procQueryInformationJobObject.Addr(), uintptr(job), uintptr(JobObjectInformationClass), uintptr(JobObjectInformation), uintptr(JobObjectInformationLength), uintptr(unsafe.Pointer(retlen)))
3063 if r1 == 0 {
3064 err = errnoErr(e1)
3065 }
3066 return
3067 }
3068
3069 func ReadConsole(console Handle, buf *uint16, toread uint32, read *uint32, inputControl *byte) (err error) {
3070 r1, _, e1 := syscall.SyscallN(procReadConsoleW.Addr(), uintptr(console), uintptr(unsafe.Pointer(buf)), uintptr(toread), uintptr(unsafe.Pointer(read)), uintptr(unsafe.Pointer(inputControl)))
3071 if r1 == 0 {
3072 err = errnoErr(e1)
3073 }
3074 return
3075 }
3076
3077 func ReadDirectoryChanges(handle Handle, buf *byte, buflen uint32, watchSubTree bool, mask uint32, retlen *uint32, overlapped *Overlapped, completionRoutine uintptr) (err error) {
3078 var _p0 uint32
3079 if watchSubTree {
3080 _p0 = 1
3081 }
3082 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))
3083 if r1 == 0 {
3084 err = errnoErr(e1)
3085 }
3086 return
3087 }
3088
3089 func readFile(handle Handle, buf []byte, done *uint32, overlapped *Overlapped) (err error) {
3090 var _p0 *byte
3091 if len(buf) > 0 {
3092 _p0 = &buf[0]
3093 }
3094 r1, _, e1 := syscall.SyscallN(procReadFile.Addr(), uintptr(handle), uintptr(unsafe.Pointer(_p0)), uintptr(len(buf)), uintptr(unsafe.Pointer(done)), uintptr(unsafe.Pointer(overlapped)))
3095 if r1 == 0 {
3096 err = errnoErr(e1)
3097 }
3098 return
3099 }
3100
3101 func ReadProcessMemory(process Handle, baseAddress uintptr, buffer *byte, size uintptr, numberOfBytesRead *uintptr) (err error) {
3102 r1, _, e1 := syscall.SyscallN(procReadProcessMemory.Addr(), uintptr(process), uintptr(baseAddress), uintptr(unsafe.Pointer(buffer)), uintptr(size), uintptr(unsafe.Pointer(numberOfBytesRead)))
3103 if r1 == 0 {
3104 err = errnoErr(e1)
3105 }
3106 return
3107 }
3108
3109 func ReleaseMutex(mutex Handle) (err error) {
3110 r1, _, e1 := syscall.SyscallN(procReleaseMutex.Addr(), uintptr(mutex))
3111 if r1 == 0 {
3112 err = errnoErr(e1)
3113 }
3114 return
3115 }
3116
3117 func RemoveDirectory(path *uint16) (err error) {
3118 r1, _, e1 := syscall.SyscallN(procRemoveDirectoryW.Addr(), uintptr(unsafe.Pointer(path)))
3119 if r1 == 0 {
3120 err = errnoErr(e1)
3121 }
3122 return
3123 }
3124
3125 func RemoveDllDirectory(cookie uintptr) (err error) {
3126 r1, _, e1 := syscall.SyscallN(procRemoveDllDirectory.Addr(), uintptr(cookie))
3127 if r1 == 0 {
3128 err = errnoErr(e1)
3129 }
3130 return
3131 }
3132
3133 func ResetEvent(event Handle) (err error) {
3134 r1, _, e1 := syscall.SyscallN(procResetEvent.Addr(), uintptr(event))
3135 if r1 == 0 {
3136 err = errnoErr(e1)
3137 }
3138 return
3139 }
3140
3141 func resizePseudoConsole(pconsole Handle, size uint32) (hr error) {
3142 r0, _, _ := syscall.SyscallN(procResizePseudoConsole.Addr(), uintptr(pconsole), uintptr(size))
3143 if r0 != 0 {
3144 hr = syscall.Errno(r0)
3145 }
3146 return
3147 }
3148
3149 func ResumeThread(thread Handle) (ret uint32, err error) {
3150 r0, _, e1 := syscall.SyscallN(procResumeThread.Addr(), uintptr(thread))
3151 ret = uint32(r0)
3152 if ret == 0xffffffff {
3153 err = errnoErr(e1)
3154 }
3155 return
3156 }
3157
3158 func SetCommBreak(handle Handle) (err error) {
3159 r1, _, e1 := syscall.SyscallN(procSetCommBreak.Addr(), uintptr(handle))
3160 if r1 == 0 {
3161 err = errnoErr(e1)
3162 }
3163 return
3164 }
3165
3166 func SetCommMask(handle Handle, dwEvtMask uint32) (err error) {
3167 r1, _, e1 := syscall.SyscallN(procSetCommMask.Addr(), uintptr(handle), uintptr(dwEvtMask))
3168 if r1 == 0 {
3169 err = errnoErr(e1)
3170 }
3171 return
3172 }
3173
3174 func SetCommState(handle Handle, lpDCB *DCB) (err error) {
3175 r1, _, e1 := syscall.SyscallN(procSetCommState.Addr(), uintptr(handle), uintptr(unsafe.Pointer(lpDCB)))
3176 if r1 == 0 {
3177 err = errnoErr(e1)
3178 }
3179 return
3180 }
3181
3182 func SetCommTimeouts(handle Handle, timeouts *CommTimeouts) (err error) {
3183 r1, _, e1 := syscall.SyscallN(procSetCommTimeouts.Addr(), uintptr(handle), uintptr(unsafe.Pointer(timeouts)))
3184 if r1 == 0 {
3185 err = errnoErr(e1)
3186 }
3187 return
3188 }
3189
3190 func SetConsoleCP(cp uint32) (err error) {
3191 r1, _, e1 := syscall.SyscallN(procSetConsoleCP.Addr(), uintptr(cp))
3192 if r1 == 0 {
3193 err = errnoErr(e1)
3194 }
3195 return
3196 }
3197
3198 func setConsoleCursorPosition(console Handle, position uint32) (err error) {
3199 r1, _, e1 := syscall.SyscallN(procSetConsoleCursorPosition.Addr(), uintptr(console), uintptr(position))
3200 if r1 == 0 {
3201 err = errnoErr(e1)
3202 }
3203 return
3204 }
3205
3206 func SetConsoleMode(console Handle, mode uint32) (err error) {
3207 r1, _, e1 := syscall.SyscallN(procSetConsoleMode.Addr(), uintptr(console), uintptr(mode))
3208 if r1 == 0 {
3209 err = errnoErr(e1)
3210 }
3211 return
3212 }
3213
3214 func SetConsoleOutputCP(cp uint32) (err error) {
3215 r1, _, e1 := syscall.SyscallN(procSetConsoleOutputCP.Addr(), uintptr(cp))
3216 if r1 == 0 {
3217 err = errnoErr(e1)
3218 }
3219 return
3220 }
3221
3222 func SetCurrentDirectory(path *uint16) (err error) {
3223 r1, _, e1 := syscall.SyscallN(procSetCurrentDirectoryW.Addr(), uintptr(unsafe.Pointer(path)))
3224 if r1 == 0 {
3225 err = errnoErr(e1)
3226 }
3227 return
3228 }
3229
3230 func SetDefaultDllDirectories(directoryFlags uint32) (err error) {
3231 r1, _, e1 := syscall.SyscallN(procSetDefaultDllDirectories.Addr(), uintptr(directoryFlags))
3232 if r1 == 0 {
3233 err = errnoErr(e1)
3234 }
3235 return
3236 }
3237
3238 func SetDllDirectory(path string) (err error) {
3239 var _p0 *uint16
3240 _p0, err = syscall.UTF16PtrFromString(path)
3241 if err != nil {
3242 return
3243 }
3244 return _SetDllDirectory(_p0)
3245 }
3246
3247 func _SetDllDirectory(path *uint16) (err error) {
3248 r1, _, e1 := syscall.SyscallN(procSetDllDirectoryW.Addr(), uintptr(unsafe.Pointer(path)))
3249 if r1 == 0 {
3250 err = errnoErr(e1)
3251 }
3252 return
3253 }
3254
3255 func SetEndOfFile(handle Handle) (err error) {
3256 r1, _, e1 := syscall.SyscallN(procSetEndOfFile.Addr(), uintptr(handle))
3257 if r1 == 0 {
3258 err = errnoErr(e1)
3259 }
3260 return
3261 }
3262
3263 func SetEnvironmentVariable(name *uint16, value *uint16) (err error) {
3264 r1, _, e1 := syscall.SyscallN(procSetEnvironmentVariableW.Addr(), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(value)))
3265 if r1 == 0 {
3266 err = errnoErr(e1)
3267 }
3268 return
3269 }
3270
3271 func SetErrorMode(mode uint32) (ret uint32) {
3272 r0, _, _ := syscall.SyscallN(procSetErrorMode.Addr(), uintptr(mode))
3273 ret = uint32(r0)
3274 return
3275 }
3276
3277 func SetEvent(event Handle) (err error) {
3278 r1, _, e1 := syscall.SyscallN(procSetEvent.Addr(), uintptr(event))
3279 if r1 == 0 {
3280 err = errnoErr(e1)
3281 }
3282 return
3283 }
3284
3285 func SetFileAttributes(name *uint16, attrs uint32) (err error) {
3286 r1, _, e1 := syscall.SyscallN(procSetFileAttributesW.Addr(), uintptr(unsafe.Pointer(name)), uintptr(attrs))
3287 if r1 == 0 {
3288 err = errnoErr(e1)
3289 }
3290 return
3291 }
3292
3293 func SetFileCompletionNotificationModes(handle Handle, flags uint8) (err error) {
3294 r1, _, e1 := syscall.SyscallN(procSetFileCompletionNotificationModes.Addr(), uintptr(handle), uintptr(flags))
3295 if r1 == 0 {
3296 err = errnoErr(e1)
3297 }
3298 return
3299 }
3300
3301 func SetFileInformationByHandle(handle Handle, class uint32, inBuffer *byte, inBufferLen uint32) (err error) {
3302 r1, _, e1 := syscall.SyscallN(procSetFileInformationByHandle.Addr(), uintptr(handle), uintptr(class), uintptr(unsafe.Pointer(inBuffer)), uintptr(inBufferLen))
3303 if r1 == 0 {
3304 err = errnoErr(e1)
3305 }
3306 return
3307 }
3308
3309 func SetFilePointer(handle Handle, lowoffset int32, highoffsetptr *int32, whence uint32) (newlowoffset uint32, err error) {
3310 r0, _, e1 := syscall.SyscallN(procSetFilePointer.Addr(), uintptr(handle), uintptr(lowoffset), uintptr(unsafe.Pointer(highoffsetptr)), uintptr(whence))
3311 newlowoffset = uint32(r0)
3312 if newlowoffset == 0xffffffff {
3313 err = errnoErr(e1)
3314 }
3315 return
3316 }
3317
3318 func SetFileTime(handle Handle, ctime *Filetime, atime *Filetime, wtime *Filetime) (err error) {
3319 r1, _, e1 := syscall.SyscallN(procSetFileTime.Addr(), uintptr(handle), uintptr(unsafe.Pointer(ctime)), uintptr(unsafe.Pointer(atime)), uintptr(unsafe.Pointer(wtime)))
3320 if r1 == 0 {
3321 err = errnoErr(e1)
3322 }
3323 return
3324 }
3325
3326 func SetFileValidData(handle Handle, validDataLength int64) (err error) {
3327 r1, _, e1 := syscall.SyscallN(procSetFileValidData.Addr(), uintptr(handle), uintptr(validDataLength))
3328 if r1 == 0 {
3329 err = errnoErr(e1)
3330 }
3331 return
3332 }
3333
3334 func SetHandleInformation(handle Handle, mask uint32, flags uint32) (err error) {
3335 r1, _, e1 := syscall.SyscallN(procSetHandleInformation.Addr(), uintptr(handle), uintptr(mask), uintptr(flags))
3336 if r1 == 0 {
3337 err = errnoErr(e1)
3338 }
3339 return
3340 }
3341
3342 func SetInformationJobObject(job Handle, JobObjectInformationClass uint32, JobObjectInformation uintptr, JobObjectInformationLength uint32) (ret int, err error) {
3343 r0, _, e1 := syscall.SyscallN(procSetInformationJobObject.Addr(), uintptr(job), uintptr(JobObjectInformationClass), uintptr(JobObjectInformation), uintptr(JobObjectInformationLength))
3344 ret = int(r0)
3345 if ret == 0 {
3346 err = errnoErr(e1)
3347 }
3348 return
3349 }
3350
3351 func SetNamedPipeHandleState(pipe Handle, state *uint32, maxCollectionCount *uint32, collectDataTimeout *uint32) (err error) {
3352 r1, _, e1 := syscall.SyscallN(procSetNamedPipeHandleState.Addr(), uintptr(pipe), uintptr(unsafe.Pointer(state)), uintptr(unsafe.Pointer(maxCollectionCount)), uintptr(unsafe.Pointer(collectDataTimeout)))
3353 if r1 == 0 {
3354 err = errnoErr(e1)
3355 }
3356 return
3357 }
3358
3359 func SetPriorityClass(process Handle, priorityClass uint32) (err error) {
3360 r1, _, e1 := syscall.SyscallN(procSetPriorityClass.Addr(), uintptr(process), uintptr(priorityClass))
3361 if r1 == 0 {
3362 err = errnoErr(e1)
3363 }
3364 return
3365 }
3366
3367 func SetProcessPriorityBoost(process Handle, disable bool) (err error) {
3368 var _p0 uint32
3369 if disable {
3370 _p0 = 1
3371 }
3372 r1, _, e1 := syscall.SyscallN(procSetProcessPriorityBoost.Addr(), uintptr(process), uintptr(_p0))
3373 if r1 == 0 {
3374 err = errnoErr(e1)
3375 }
3376 return
3377 }
3378
3379 func SetProcessShutdownParameters(level uint32, flags uint32) (err error) {
3380 r1, _, e1 := syscall.SyscallN(procSetProcessShutdownParameters.Addr(), uintptr(level), uintptr(flags))
3381 if r1 == 0 {
3382 err = errnoErr(e1)
3383 }
3384 return
3385 }
3386
3387 func SetProcessWorkingSetSizeEx(hProcess Handle, dwMinimumWorkingSetSize uintptr, dwMaximumWorkingSetSize uintptr, flags uint32) (err error) {
3388 r1, _, e1 := syscall.SyscallN(procSetProcessWorkingSetSizeEx.Addr(), uintptr(hProcess), uintptr(dwMinimumWorkingSetSize), uintptr(dwMaximumWorkingSetSize), uintptr(flags))
3389 if r1 == 0 {
3390 err = errnoErr(e1)
3391 }
3392 return
3393 }
3394
3395 func SetStdHandle(stdhandle uint32, handle Handle) (err error) {
3396 r1, _, e1 := syscall.SyscallN(procSetStdHandle.Addr(), uintptr(stdhandle), uintptr(handle))
3397 if r1 == 0 {
3398 err = errnoErr(e1)
3399 }
3400 return
3401 }
3402
3403 func SetVolumeLabel(rootPathName *uint16, volumeName *uint16) (err error) {
3404 r1, _, e1 := syscall.SyscallN(procSetVolumeLabelW.Addr(), uintptr(unsafe.Pointer(rootPathName)), uintptr(unsafe.Pointer(volumeName)))
3405 if r1 == 0 {
3406 err = errnoErr(e1)
3407 }
3408 return
3409 }
3410
3411 func SetVolumeMountPoint(volumeMountPoint *uint16, volumeName *uint16) (err error) {
3412 r1, _, e1 := syscall.SyscallN(procSetVolumeMountPointW.Addr(), uintptr(unsafe.Pointer(volumeMountPoint)), uintptr(unsafe.Pointer(volumeName)))
3413 if r1 == 0 {
3414 err = errnoErr(e1)
3415 }
3416 return
3417 }
3418
3419 func SetupComm(handle Handle, dwInQueue uint32, dwOutQueue uint32) (err error) {
3420 r1, _, e1 := syscall.SyscallN(procSetupComm.Addr(), uintptr(handle), uintptr(dwInQueue), uintptr(dwOutQueue))
3421 if r1 == 0 {
3422 err = errnoErr(e1)
3423 }
3424 return
3425 }
3426
3427 func SizeofResource(module Handle, resInfo Handle) (size uint32, err error) {
3428 r0, _, e1 := syscall.SyscallN(procSizeofResource.Addr(), uintptr(module), uintptr(resInfo))
3429 size = uint32(r0)
3430 if size == 0 {
3431 err = errnoErr(e1)
3432 }
3433 return
3434 }
3435
3436 func SleepEx(milliseconds uint32, alertable bool) (ret uint32) {
3437 var _p0 uint32
3438 if alertable {
3439 _p0 = 1
3440 }
3441 r0, _, _ := syscall.SyscallN(procSleepEx.Addr(), uintptr(milliseconds), uintptr(_p0))
3442 ret = uint32(r0)
3443 return
3444 }
3445
3446 func TerminateJobObject(job Handle, exitCode uint32) (err error) {
3447 r1, _, e1 := syscall.SyscallN(procTerminateJobObject.Addr(), uintptr(job), uintptr(exitCode))
3448 if r1 == 0 {
3449 err = errnoErr(e1)
3450 }
3451 return
3452 }
3453
3454 func TerminateProcess(handle Handle, exitcode uint32) (err error) {
3455 r1, _, e1 := syscall.SyscallN(procTerminateProcess.Addr(), uintptr(handle), uintptr(exitcode))
3456 if r1 == 0 {
3457 err = errnoErr(e1)
3458 }
3459 return
3460 }
3461
3462 func Thread32First(snapshot Handle, threadEntry *ThreadEntry32) (err error) {
3463 r1, _, e1 := syscall.SyscallN(procThread32First.Addr(), uintptr(snapshot), uintptr(unsafe.Pointer(threadEntry)))
3464 if r1 == 0 {
3465 err = errnoErr(e1)
3466 }
3467 return
3468 }
3469
3470 func Thread32Next(snapshot Handle, threadEntry *ThreadEntry32) (err error) {
3471 r1, _, e1 := syscall.SyscallN(procThread32Next.Addr(), uintptr(snapshot), uintptr(unsafe.Pointer(threadEntry)))
3472 if r1 == 0 {
3473 err = errnoErr(e1)
3474 }
3475 return
3476 }
3477
3478 func UnlockFileEx(file Handle, reserved uint32, bytesLow uint32, bytesHigh uint32, overlapped *Overlapped) (err error) {
3479 r1, _, e1 := syscall.SyscallN(procUnlockFileEx.Addr(), uintptr(file), uintptr(reserved), uintptr(bytesLow), uintptr(bytesHigh), uintptr(unsafe.Pointer(overlapped)))
3480 if r1 == 0 {
3481 err = errnoErr(e1)
3482 }
3483 return
3484 }
3485
3486 func UnmapViewOfFile(addr uintptr) (err error) {
3487 r1, _, e1 := syscall.SyscallN(procUnmapViewOfFile.Addr(), uintptr(addr))
3488 if r1 == 0 {
3489 err = errnoErr(e1)
3490 }
3491 return
3492 }
3493
3494 func updateProcThreadAttribute(attrlist *ProcThreadAttributeList, flags uint32, attr uintptr, value unsafe.Pointer, size uintptr, prevvalue unsafe.Pointer, returnedsize *uintptr) (err error) {
3495 r1, _, e1 := syscall.SyscallN(procUpdateProcThreadAttribute.Addr(), uintptr(unsafe.Pointer(attrlist)), uintptr(flags), uintptr(attr), uintptr(value), uintptr(size), uintptr(prevvalue), uintptr(unsafe.Pointer(returnedsize)))
3496 if r1 == 0 {
3497 err = errnoErr(e1)
3498 }
3499 return
3500 }
3501
3502 func VirtualAlloc(address uintptr, size uintptr, alloctype uint32, protect uint32) (value uintptr, err error) {
3503 r0, _, e1 := syscall.SyscallN(procVirtualAlloc.Addr(), uintptr(address), uintptr(size), uintptr(alloctype), uintptr(protect))
3504 value = uintptr(r0)
3505 if value == 0 {
3506 err = errnoErr(e1)
3507 }
3508 return
3509 }
3510
3511 func VirtualFree(address uintptr, size uintptr, freetype uint32) (err error) {
3512 r1, _, e1 := syscall.SyscallN(procVirtualFree.Addr(), uintptr(address), uintptr(size), uintptr(freetype))
3513 if r1 == 0 {
3514 err = errnoErr(e1)
3515 }
3516 return
3517 }
3518
3519 func VirtualLock(addr uintptr, length uintptr) (err error) {
3520 r1, _, e1 := syscall.SyscallN(procVirtualLock.Addr(), uintptr(addr), uintptr(length))
3521 if r1 == 0 {
3522 err = errnoErr(e1)
3523 }
3524 return
3525 }
3526
3527 func VirtualProtect(address uintptr, size uintptr, newprotect uint32, oldprotect *uint32) (err error) {
3528 r1, _, e1 := syscall.SyscallN(procVirtualProtect.Addr(), uintptr(address), uintptr(size), uintptr(newprotect), uintptr(unsafe.Pointer(oldprotect)))
3529 if r1 == 0 {
3530 err = errnoErr(e1)
3531 }
3532 return
3533 }
3534
3535 func VirtualProtectEx(process Handle, address uintptr, size uintptr, newProtect uint32, oldProtect *uint32) (err error) {
3536 r1, _, e1 := syscall.SyscallN(procVirtualProtectEx.Addr(), uintptr(process), uintptr(address), uintptr(size), uintptr(newProtect), uintptr(unsafe.Pointer(oldProtect)))
3537 if r1 == 0 {
3538 err = errnoErr(e1)
3539 }
3540 return
3541 }
3542
3543 func VirtualQuery(address uintptr, buffer *MemoryBasicInformation, length uintptr) (err error) {
3544 r1, _, e1 := syscall.SyscallN(procVirtualQuery.Addr(), uintptr(address), uintptr(unsafe.Pointer(buffer)), uintptr(length))
3545 if r1 == 0 {
3546 err = errnoErr(e1)
3547 }
3548 return
3549 }
3550
3551 func VirtualQueryEx(process Handle, address uintptr, buffer *MemoryBasicInformation, length uintptr) (err error) {
3552 r1, _, e1 := syscall.SyscallN(procVirtualQueryEx.Addr(), uintptr(process), uintptr(address), uintptr(unsafe.Pointer(buffer)), uintptr(length))
3553 if r1 == 0 {
3554 err = errnoErr(e1)
3555 }
3556 return
3557 }
3558
3559 func VirtualUnlock(addr uintptr, length uintptr) (err error) {
3560 r1, _, e1 := syscall.SyscallN(procVirtualUnlock.Addr(), uintptr(addr), uintptr(length))
3561 if r1 == 0 {
3562 err = errnoErr(e1)
3563 }
3564 return
3565 }
3566
3567 func WTSGetActiveConsoleSessionId() (sessionID uint32) {
3568 r0, _, _ := syscall.SyscallN(procWTSGetActiveConsoleSessionId.Addr())
3569 sessionID = uint32(r0)
3570 return
3571 }
3572
3573 func WaitCommEvent(handle Handle, lpEvtMask *uint32, lpOverlapped *Overlapped) (err error) {
3574 r1, _, e1 := syscall.SyscallN(procWaitCommEvent.Addr(), uintptr(handle), uintptr(unsafe.Pointer(lpEvtMask)), uintptr(unsafe.Pointer(lpOverlapped)))
3575 if r1 == 0 {
3576 err = errnoErr(e1)
3577 }
3578 return
3579 }
3580
3581 func waitForMultipleObjects(count uint32, handles uintptr, waitAll bool, waitMilliseconds uint32) (event uint32, err error) {
3582 var _p0 uint32
3583 if waitAll {
3584 _p0 = 1
3585 }
3586 r0, _, e1 := syscall.SyscallN(procWaitForMultipleObjects.Addr(), uintptr(count), uintptr(handles), uintptr(_p0), uintptr(waitMilliseconds))
3587 event = uint32(r0)
3588 if event == 0xffffffff {
3589 err = errnoErr(e1)
3590 }
3591 return
3592 }
3593
3594 func WaitForSingleObject(handle Handle, waitMilliseconds uint32) (event uint32, err error) {
3595 r0, _, e1 := syscall.SyscallN(procWaitForSingleObject.Addr(), uintptr(handle), uintptr(waitMilliseconds))
3596 event = uint32(r0)
3597 if event == 0xffffffff {
3598 err = errnoErr(e1)
3599 }
3600 return
3601 }
3602
3603 func WriteConsole(console Handle, buf *uint16, towrite uint32, written *uint32, reserved *byte) (err error) {
3604 r1, _, e1 := syscall.SyscallN(procWriteConsoleW.Addr(), uintptr(console), uintptr(unsafe.Pointer(buf)), uintptr(towrite), uintptr(unsafe.Pointer(written)), uintptr(unsafe.Pointer(reserved)))
3605 if r1 == 0 {
3606 err = errnoErr(e1)
3607 }
3608 return
3609 }
3610
3611 func writeFile(handle Handle, buf []byte, done *uint32, overlapped *Overlapped) (err error) {
3612 var _p0 *byte
3613 if len(buf) > 0 {
3614 _p0 = &buf[0]
3615 }
3616 r1, _, e1 := syscall.SyscallN(procWriteFile.Addr(), uintptr(handle), uintptr(unsafe.Pointer(_p0)), uintptr(len(buf)), uintptr(unsafe.Pointer(done)), uintptr(unsafe.Pointer(overlapped)))
3617 if r1 == 0 {
3618 err = errnoErr(e1)
3619 }
3620 return
3621 }
3622
3623 func WriteProcessMemory(process Handle, baseAddress uintptr, buffer *byte, size uintptr, numberOfBytesWritten *uintptr) (err error) {
3624 r1, _, e1 := syscall.SyscallN(procWriteProcessMemory.Addr(), uintptr(process), uintptr(baseAddress), uintptr(unsafe.Pointer(buffer)), uintptr(size), uintptr(unsafe.Pointer(numberOfBytesWritten)))
3625 if r1 == 0 {
3626 err = errnoErr(e1)
3627 }
3628 return
3629 }
3630
3631 func AcceptEx(ls Handle, as Handle, buf *byte, rxdatalen uint32, laddrlen uint32, raddrlen uint32, recvd *uint32, overlapped *Overlapped) (err error) {
3632 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)))
3633 if r1 == 0 {
3634 err = errnoErr(e1)
3635 }
3636 return
3637 }
3638
3639 func GetAcceptExSockaddrs(buf *byte, rxdatalen uint32, laddrlen uint32, raddrlen uint32, lrsa **RawSockaddrAny, lrsalen *int32, rrsa **RawSockaddrAny, rrsalen *int32) {
3640 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)))
3641 return
3642 }
3643
3644 func TransmitFile(s Handle, handle Handle, bytesToWrite uint32, bytsPerSend uint32, overlapped *Overlapped, transmitFileBuf *TransmitFileBuffers, flags uint32) (err error) {
3645 r1, _, e1 := syscall.SyscallN(procTransmitFile.Addr(), uintptr(s), uintptr(handle), uintptr(bytesToWrite), uintptr(bytsPerSend), uintptr(unsafe.Pointer(overlapped)), uintptr(unsafe.Pointer(transmitFileBuf)), uintptr(flags))
3646 if r1 == 0 {
3647 err = errnoErr(e1)
3648 }
3649 return
3650 }
3651
3652 func NetApiBufferFree(buf *byte) (neterr error) {
3653 r0, _, _ := syscall.SyscallN(procNetApiBufferFree.Addr(), uintptr(unsafe.Pointer(buf)))
3654 if r0 != 0 {
3655 neterr = syscall.Errno(r0)
3656 }
3657 return
3658 }
3659
3660 func NetGetJoinInformation(server *uint16, name **uint16, bufType *uint32) (neterr error) {
3661 r0, _, _ := syscall.SyscallN(procNetGetJoinInformation.Addr(), uintptr(unsafe.Pointer(server)), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(bufType)))
3662 if r0 != 0 {
3663 neterr = syscall.Errno(r0)
3664 }
3665 return
3666 }
3667
3668 func NetUserEnum(serverName *uint16, level uint32, filter uint32, buf **byte, prefMaxLen uint32, entriesRead *uint32, totalEntries *uint32, resumeHandle *uint32) (neterr error) {
3669 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)))
3670 if r0 != 0 {
3671 neterr = syscall.Errno(r0)
3672 }
3673 return
3674 }
3675
3676 func NetUserGetInfo(serverName *uint16, userName *uint16, level uint32, buf **byte) (neterr error) {
3677 r0, _, _ := syscall.SyscallN(procNetUserGetInfo.Addr(), uintptr(unsafe.Pointer(serverName)), uintptr(unsafe.Pointer(userName)), uintptr(level), uintptr(unsafe.Pointer(buf)))
3678 if r0 != 0 {
3679 neterr = syscall.Errno(r0)
3680 }
3681 return
3682 }
3683
3684 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) {
3685 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))
3686 if r0 != 0 {
3687 ntstatus = NTStatus(r0)
3688 }
3689 return
3690 }
3691
3692 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) {
3693 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)))
3694 if r0 != 0 {
3695 ntstatus = NTStatus(r0)
3696 }
3697 return
3698 }
3699
3700 func NtQueryInformationProcess(proc Handle, procInfoClass int32, procInfo unsafe.Pointer, procInfoLen uint32, retLen *uint32) (ntstatus error) {
3701 r0, _, _ := syscall.SyscallN(procNtQueryInformationProcess.Addr(), uintptr(proc), uintptr(procInfoClass), uintptr(procInfo), uintptr(procInfoLen), uintptr(unsafe.Pointer(retLen)))
3702 if r0 != 0 {
3703 ntstatus = NTStatus(r0)
3704 }
3705 return
3706 }
3707
3708 func NtQuerySystemInformation(sysInfoClass int32, sysInfo unsafe.Pointer, sysInfoLen uint32, retLen *uint32) (ntstatus error) {
3709 r0, _, _ := syscall.SyscallN(procNtQuerySystemInformation.Addr(), uintptr(sysInfoClass), uintptr(sysInfo), uintptr(sysInfoLen), uintptr(unsafe.Pointer(retLen)))
3710 if r0 != 0 {
3711 ntstatus = NTStatus(r0)
3712 }
3713 return
3714 }
3715
3716 func NtSetInformationFile(handle Handle, iosb *IO_STATUS_BLOCK, inBuffer *byte, inBufferLen uint32, class uint32) (ntstatus error) {
3717 r0, _, _ := syscall.SyscallN(procNtSetInformationFile.Addr(), uintptr(handle), uintptr(unsafe.Pointer(iosb)), uintptr(unsafe.Pointer(inBuffer)), uintptr(inBufferLen), uintptr(class))
3718 if r0 != 0 {
3719 ntstatus = NTStatus(r0)
3720 }
3721 return
3722 }
3723
3724 func NtSetInformationProcess(proc Handle, procInfoClass int32, procInfo unsafe.Pointer, procInfoLen uint32) (ntstatus error) {
3725 r0, _, _ := syscall.SyscallN(procNtSetInformationProcess.Addr(), uintptr(proc), uintptr(procInfoClass), uintptr(procInfo), uintptr(procInfoLen))
3726 if r0 != 0 {
3727 ntstatus = NTStatus(r0)
3728 }
3729 return
3730 }
3731
3732 func NtSetSystemInformation(sysInfoClass int32, sysInfo unsafe.Pointer, sysInfoLen uint32) (ntstatus error) {
3733 r0, _, _ := syscall.SyscallN(procNtSetSystemInformation.Addr(), uintptr(sysInfoClass), uintptr(sysInfo), uintptr(sysInfoLen))
3734 if r0 != 0 {
3735 ntstatus = NTStatus(r0)
3736 }
3737 return
3738 }
3739
3740 func RtlAddFunctionTable(functionTable *RUNTIME_FUNCTION, entryCount uint32, baseAddress uintptr) (ret bool) {
3741 r0, _, _ := syscall.SyscallN(procRtlAddFunctionTable.Addr(), uintptr(unsafe.Pointer(functionTable)), uintptr(entryCount), uintptr(baseAddress))
3742 ret = r0 != 0
3743 return
3744 }
3745
3746 func RtlDefaultNpAcl(acl **ACL) (ntstatus error) {
3747 r0, _, _ := syscall.SyscallN(procRtlDefaultNpAcl.Addr(), uintptr(unsafe.Pointer(acl)))
3748 if r0 != 0 {
3749 ntstatus = NTStatus(r0)
3750 }
3751 return
3752 }
3753
3754 func RtlDeleteFunctionTable(functionTable *RUNTIME_FUNCTION) (ret bool) {
3755 r0, _, _ := syscall.SyscallN(procRtlDeleteFunctionTable.Addr(), uintptr(unsafe.Pointer(functionTable)))
3756 ret = r0 != 0
3757 return
3758 }
3759
3760 func RtlDosPathNameToNtPathName(dosName *uint16, ntName *NTUnicodeString, ntFileNamePart *uint16, relativeName *RTL_RELATIVE_NAME) (ntstatus error) {
3761 r0, _, _ := syscall.SyscallN(procRtlDosPathNameToNtPathName_U_WithStatus.Addr(), uintptr(unsafe.Pointer(dosName)), uintptr(unsafe.Pointer(ntName)), uintptr(unsafe.Pointer(ntFileNamePart)), uintptr(unsafe.Pointer(relativeName)))
3762 if r0 != 0 {
3763 ntstatus = NTStatus(r0)
3764 }
3765 return
3766 }
3767
3768 func RtlDosPathNameToRelativeNtPathName(dosName *uint16, ntName *NTUnicodeString, ntFileNamePart *uint16, relativeName *RTL_RELATIVE_NAME) (ntstatus error) {
3769 r0, _, _ := syscall.SyscallN(procRtlDosPathNameToRelativeNtPathName_U_WithStatus.Addr(), uintptr(unsafe.Pointer(dosName)), uintptr(unsafe.Pointer(ntName)), uintptr(unsafe.Pointer(ntFileNamePart)), uintptr(unsafe.Pointer(relativeName)))
3770 if r0 != 0 {
3771 ntstatus = NTStatus(r0)
3772 }
3773 return
3774 }
3775
3776 func RtlGetCurrentPeb() (peb *PEB) {
3777 r0, _, _ := syscall.SyscallN(procRtlGetCurrentPeb.Addr())
3778 peb = (*PEB)(unsafe.Pointer(r0))
3779 return
3780 }
3781
3782 func rtlGetNtVersionNumbers(majorVersion *uint32, minorVersion *uint32, buildNumber *uint32) {
3783 syscall.SyscallN(procRtlGetNtVersionNumbers.Addr(), uintptr(unsafe.Pointer(majorVersion)), uintptr(unsafe.Pointer(minorVersion)), uintptr(unsafe.Pointer(buildNumber)))
3784 return
3785 }
3786
3787 func rtlGetVersion(info *OsVersionInfoEx) (ntstatus error) {
3788 r0, _, _ := syscall.SyscallN(procRtlGetVersion.Addr(), uintptr(unsafe.Pointer(info)))
3789 if r0 != 0 {
3790 ntstatus = NTStatus(r0)
3791 }
3792 return
3793 }
3794
3795 func RtlInitString(destinationString *NTString, sourceString *byte) {
3796 syscall.SyscallN(procRtlInitString.Addr(), uintptr(unsafe.Pointer(destinationString)), uintptr(unsafe.Pointer(sourceString)))
3797 return
3798 }
3799
3800 func RtlInitUnicodeString(destinationString *NTUnicodeString, sourceString *uint16) {
3801 syscall.SyscallN(procRtlInitUnicodeString.Addr(), uintptr(unsafe.Pointer(destinationString)), uintptr(unsafe.Pointer(sourceString)))
3802 return
3803 }
3804
3805 func rtlNtStatusToDosErrorNoTeb(ntstatus NTStatus) (ret syscall.Errno) {
3806 r0, _, _ := syscall.SyscallN(procRtlNtStatusToDosErrorNoTeb.Addr(), uintptr(ntstatus))
3807 ret = syscall.Errno(r0)
3808 return
3809 }
3810
3811 func clsidFromString(lpsz *uint16, pclsid *GUID) (ret error) {
3812 r0, _, _ := syscall.SyscallN(procCLSIDFromString.Addr(), uintptr(unsafe.Pointer(lpsz)), uintptr(unsafe.Pointer(pclsid)))
3813 if r0 != 0 {
3814 ret = syscall.Errno(r0)
3815 }
3816 return
3817 }
3818
3819 func coCreateGuid(pguid *GUID) (ret error) {
3820 r0, _, _ := syscall.SyscallN(procCoCreateGuid.Addr(), uintptr(unsafe.Pointer(pguid)))
3821 if r0 != 0 {
3822 ret = syscall.Errno(r0)
3823 }
3824 return
3825 }
3826
3827 func CoGetObject(name *uint16, bindOpts *BIND_OPTS3, guid *GUID, functionTable **uintptr) (ret error) {
3828 r0, _, _ := syscall.SyscallN(procCoGetObject.Addr(), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(bindOpts)), uintptr(unsafe.Pointer(guid)), uintptr(unsafe.Pointer(functionTable)))
3829 if r0 != 0 {
3830 ret = syscall.Errno(r0)
3831 }
3832 return
3833 }
3834
3835 func CoInitializeEx(reserved uintptr, coInit uint32) (ret error) {
3836 r0, _, _ := syscall.SyscallN(procCoInitializeEx.Addr(), uintptr(reserved), uintptr(coInit))
3837 if r0 != 0 {
3838 ret = syscall.Errno(r0)
3839 }
3840 return
3841 }
3842
3843 func CoTaskMemFree(address unsafe.Pointer) {
3844 syscall.SyscallN(procCoTaskMemFree.Addr(), uintptr(address))
3845 return
3846 }
3847
3848 func CoUninitialize() {
3849 syscall.SyscallN(procCoUninitialize.Addr())
3850 return
3851 }
3852
3853 func stringFromGUID2(rguid *GUID, lpsz *uint16, cchMax int32) (chars int32) {
3854 r0, _, _ := syscall.SyscallN(procStringFromGUID2.Addr(), uintptr(unsafe.Pointer(rguid)), uintptr(unsafe.Pointer(lpsz)), uintptr(cchMax))
3855 chars = int32(r0)
3856 return
3857 }
3858
3859 func EnumProcessModules(process Handle, module *Handle, cb uint32, cbNeeded *uint32) (err error) {
3860 r1, _, e1 := syscall.SyscallN(procEnumProcessModules.Addr(), uintptr(process), uintptr(unsafe.Pointer(module)), uintptr(cb), uintptr(unsafe.Pointer(cbNeeded)))
3861 if r1 == 0 {
3862 err = errnoErr(e1)
3863 }
3864 return
3865 }
3866
3867 func EnumProcessModulesEx(process Handle, module *Handle, cb uint32, cbNeeded *uint32, filterFlag uint32) (err error) {
3868 r1, _, e1 := syscall.SyscallN(procEnumProcessModulesEx.Addr(), uintptr(process), uintptr(unsafe.Pointer(module)), uintptr(cb), uintptr(unsafe.Pointer(cbNeeded)), uintptr(filterFlag))
3869 if r1 == 0 {
3870 err = errnoErr(e1)
3871 }
3872 return
3873 }
3874
3875 func enumProcesses(processIds *uint32, nSize uint32, bytesReturned *uint32) (err error) {
3876 r1, _, e1 := syscall.SyscallN(procEnumProcesses.Addr(), uintptr(unsafe.Pointer(processIds)), uintptr(nSize), uintptr(unsafe.Pointer(bytesReturned)))
3877 if r1 == 0 {
3878 err = errnoErr(e1)
3879 }
3880 return
3881 }
3882
3883 func GetModuleBaseName(process Handle, module Handle, baseName *uint16, size uint32) (err error) {
3884 r1, _, e1 := syscall.SyscallN(procGetModuleBaseNameW.Addr(), uintptr(process), uintptr(module), uintptr(unsafe.Pointer(baseName)), uintptr(size))
3885 if r1 == 0 {
3886 err = errnoErr(e1)
3887 }
3888 return
3889 }
3890
3891 func GetModuleFileNameEx(process Handle, module Handle, filename *uint16, size uint32) (err error) {
3892 r1, _, e1 := syscall.SyscallN(procGetModuleFileNameExW.Addr(), uintptr(process), uintptr(module), uintptr(unsafe.Pointer(filename)), uintptr(size))
3893 if r1 == 0 {
3894 err = errnoErr(e1)
3895 }
3896 return
3897 }
3898
3899 func GetModuleInformation(process Handle, module Handle, modinfo *ModuleInfo, cb uint32) (err error) {
3900 r1, _, e1 := syscall.SyscallN(procGetModuleInformation.Addr(), uintptr(process), uintptr(module), uintptr(unsafe.Pointer(modinfo)), uintptr(cb))
3901 if r1 == 0 {
3902 err = errnoErr(e1)
3903 }
3904 return
3905 }
3906
3907 func QueryWorkingSetEx(process Handle, pv uintptr, cb uint32) (err error) {
3908 r1, _, e1 := syscall.SyscallN(procQueryWorkingSetEx.Addr(), uintptr(process), uintptr(pv), uintptr(cb))
3909 if r1 == 0 {
3910 err = errnoErr(e1)
3911 }
3912 return
3913 }
3914
3915 func SubscribeServiceChangeNotifications(service Handle, eventType uint32, callback uintptr, callbackCtx uintptr, subscription *uintptr) (ret error) {
3916 ret = procSubscribeServiceChangeNotifications.Find()
3917 if ret != nil {
3918 return
3919 }
3920 r0, _, _ := syscall.SyscallN(procSubscribeServiceChangeNotifications.Addr(), uintptr(service), uintptr(eventType), uintptr(callback), uintptr(callbackCtx), uintptr(unsafe.Pointer(subscription)))
3921 if r0 != 0 {
3922 ret = syscall.Errno(r0)
3923 }
3924 return
3925 }
3926
3927 func UnsubscribeServiceChangeNotifications(subscription uintptr) (err error) {
3928 err = procUnsubscribeServiceChangeNotifications.Find()
3929 if err != nil {
3930 return
3931 }
3932 syscall.SyscallN(procUnsubscribeServiceChangeNotifications.Addr(), uintptr(subscription))
3933 return
3934 }
3935
3936 func GetUserNameEx(nameFormat uint32, nameBuffre *uint16, nSize *uint32) (err error) {
3937 r1, _, e1 := syscall.SyscallN(procGetUserNameExW.Addr(), uintptr(nameFormat), uintptr(unsafe.Pointer(nameBuffre)), uintptr(unsafe.Pointer(nSize)))
3938 if r1&0xff == 0 {
3939 err = errnoErr(e1)
3940 }
3941 return
3942 }
3943
3944 func TranslateName(accName *uint16, accNameFormat uint32, desiredNameFormat uint32, translatedName *uint16, nSize *uint32) (err error) {
3945 r1, _, e1 := syscall.SyscallN(procTranslateNameW.Addr(), uintptr(unsafe.Pointer(accName)), uintptr(accNameFormat), uintptr(desiredNameFormat), uintptr(unsafe.Pointer(translatedName)), uintptr(unsafe.Pointer(nSize)))
3946 if r1&0xff == 0 {
3947 err = errnoErr(e1)
3948 }
3949 return
3950 }
3951
3952 func SetupDiBuildDriverInfoList(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverType SPDIT) (err error) {
3953 r1, _, e1 := syscall.SyscallN(procSetupDiBuildDriverInfoList.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(driverType))
3954 if r1 == 0 {
3955 err = errnoErr(e1)
3956 }
3957 return
3958 }
3959
3960 func SetupDiCallClassInstaller(installFunction DI_FUNCTION, deviceInfoSet DevInfo, deviceInfoData *DevInfoData) (err error) {
3961 r1, _, e1 := syscall.SyscallN(procSetupDiCallClassInstaller.Addr(), uintptr(installFunction), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)))
3962 if r1 == 0 {
3963 err = errnoErr(e1)
3964 }
3965 return
3966 }
3967
3968 func SetupDiCancelDriverInfoSearch(deviceInfoSet DevInfo) (err error) {
3969 r1, _, e1 := syscall.SyscallN(procSetupDiCancelDriverInfoSearch.Addr(), uintptr(deviceInfoSet))
3970 if r1 == 0 {
3971 err = errnoErr(e1)
3972 }
3973 return
3974 }
3975
3976 func setupDiClassGuidsFromNameEx(className *uint16, classGuidList *GUID, classGuidListSize uint32, requiredSize *uint32, machineName *uint16, reserved uintptr) (err error) {
3977 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))
3978 if r1 == 0 {
3979 err = errnoErr(e1)
3980 }
3981 return
3982 }
3983
3984 func setupDiClassNameFromGuidEx(classGUID *GUID, className *uint16, classNameSize uint32, requiredSize *uint32, machineName *uint16, reserved uintptr) (err error) {
3985 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))
3986 if r1 == 0 {
3987 err = errnoErr(e1)
3988 }
3989 return
3990 }
3991
3992 func setupDiCreateDeviceInfoListEx(classGUID *GUID, hwndParent uintptr, machineName *uint16, reserved uintptr) (handle DevInfo, err error) {
3993 r0, _, e1 := syscall.SyscallN(procSetupDiCreateDeviceInfoListExW.Addr(), uintptr(unsafe.Pointer(classGUID)), uintptr(hwndParent), uintptr(unsafe.Pointer(machineName)), uintptr(reserved))
3994 handle = DevInfo(r0)
3995 if handle == DevInfo(InvalidHandle) {
3996 err = errnoErr(e1)
3997 }
3998 return
3999 }
4000
4001 func setupDiCreateDeviceInfo(deviceInfoSet DevInfo, DeviceName *uint16, classGUID *GUID, DeviceDescription *uint16, hwndParent uintptr, CreationFlags DICD, deviceInfoData *DevInfoData) (err error) {
4002 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)))
4003 if r1 == 0 {
4004 err = errnoErr(e1)
4005 }
4006 return
4007 }
4008
4009 func SetupDiDestroyDeviceInfoList(deviceInfoSet DevInfo) (err error) {
4010 r1, _, e1 := syscall.SyscallN(procSetupDiDestroyDeviceInfoList.Addr(), uintptr(deviceInfoSet))
4011 if r1 == 0 {
4012 err = errnoErr(e1)
4013 }
4014 return
4015 }
4016
4017 func SetupDiDestroyDriverInfoList(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverType SPDIT) (err error) {
4018 r1, _, e1 := syscall.SyscallN(procSetupDiDestroyDriverInfoList.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(driverType))
4019 if r1 == 0 {
4020 err = errnoErr(e1)
4021 }
4022 return
4023 }
4024
4025 func setupDiEnumDeviceInfo(deviceInfoSet DevInfo, memberIndex uint32, deviceInfoData *DevInfoData) (err error) {
4026 r1, _, e1 := syscall.SyscallN(procSetupDiEnumDeviceInfo.Addr(), uintptr(deviceInfoSet), uintptr(memberIndex), uintptr(unsafe.Pointer(deviceInfoData)))
4027 if r1 == 0 {
4028 err = errnoErr(e1)
4029 }
4030 return
4031 }
4032
4033 func setupDiEnumDriverInfo(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverType SPDIT, memberIndex uint32, driverInfoData *DrvInfoData) (err error) {
4034 r1, _, e1 := syscall.SyscallN(procSetupDiEnumDriverInfoW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(driverType), uintptr(memberIndex), uintptr(unsafe.Pointer(driverInfoData)))
4035 if r1 == 0 {
4036 err = errnoErr(e1)
4037 }
4038 return
4039 }
4040
4041 func setupDiGetClassDevsEx(classGUID *GUID, Enumerator *uint16, hwndParent uintptr, Flags DIGCF, deviceInfoSet DevInfo, machineName *uint16, reserved uintptr) (handle DevInfo, err error) {
4042 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))
4043 handle = DevInfo(r0)
4044 if handle == DevInfo(InvalidHandle) {
4045 err = errnoErr(e1)
4046 }
4047 return
4048 }
4049
4050 func SetupDiGetClassInstallParams(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, classInstallParams *ClassInstallHeader, classInstallParamsSize uint32, requiredSize *uint32) (err error) {
4051 r1, _, e1 := syscall.SyscallN(procSetupDiGetClassInstallParamsW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(classInstallParams)), uintptr(classInstallParamsSize), uintptr(unsafe.Pointer(requiredSize)))
4052 if r1 == 0 {
4053 err = errnoErr(e1)
4054 }
4055 return
4056 }
4057
4058 func setupDiGetDeviceInfoListDetail(deviceInfoSet DevInfo, deviceInfoSetDetailData *DevInfoListDetailData) (err error) {
4059 r1, _, e1 := syscall.SyscallN(procSetupDiGetDeviceInfoListDetailW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoSetDetailData)))
4060 if r1 == 0 {
4061 err = errnoErr(e1)
4062 }
4063 return
4064 }
4065
4066 func setupDiGetDeviceInstallParams(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, deviceInstallParams *DevInstallParams) (err error) {
4067 r1, _, e1 := syscall.SyscallN(procSetupDiGetDeviceInstallParamsW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(deviceInstallParams)))
4068 if r1 == 0 {
4069 err = errnoErr(e1)
4070 }
4071 return
4072 }
4073
4074 func setupDiGetDeviceInstanceId(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, instanceId *uint16, instanceIdSize uint32, instanceIdRequiredSize *uint32) (err error) {
4075 r1, _, e1 := syscall.SyscallN(procSetupDiGetDeviceInstanceIdW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(instanceId)), uintptr(instanceIdSize), uintptr(unsafe.Pointer(instanceIdRequiredSize)))
4076 if r1 == 0 {
4077 err = errnoErr(e1)
4078 }
4079 return
4080 }
4081
4082 func setupDiGetDeviceProperty(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, propertyKey *DEVPROPKEY, propertyType *DEVPROPTYPE, propertyBuffer *byte, propertyBufferSize uint32, requiredSize *uint32, flags uint32) (err error) {
4083 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))
4084 if r1 == 0 {
4085 err = errnoErr(e1)
4086 }
4087 return
4088 }
4089
4090 func setupDiGetDeviceRegistryProperty(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, property SPDRP, propertyRegDataType *uint32, propertyBuffer *byte, propertyBufferSize uint32, requiredSize *uint32) (err error) {
4091 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)))
4092 if r1 == 0 {
4093 err = errnoErr(e1)
4094 }
4095 return
4096 }
4097
4098 func setupDiGetDriverInfoDetail(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverInfoData *DrvInfoData, driverInfoDetailData *DrvInfoDetailData, driverInfoDetailDataSize uint32, requiredSize *uint32) (err error) {
4099 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)))
4100 if r1 == 0 {
4101 err = errnoErr(e1)
4102 }
4103 return
4104 }
4105
4106 func setupDiGetSelectedDevice(deviceInfoSet DevInfo, deviceInfoData *DevInfoData) (err error) {
4107 r1, _, e1 := syscall.SyscallN(procSetupDiGetSelectedDevice.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)))
4108 if r1 == 0 {
4109 err = errnoErr(e1)
4110 }
4111 return
4112 }
4113
4114 func setupDiGetSelectedDriver(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverInfoData *DrvInfoData) (err error) {
4115 r1, _, e1 := syscall.SyscallN(procSetupDiGetSelectedDriverW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(driverInfoData)))
4116 if r1 == 0 {
4117 err = errnoErr(e1)
4118 }
4119 return
4120 }
4121
4122 func SetupDiOpenDevRegKey(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, Scope DICS_FLAG, HwProfile uint32, KeyType DIREG, samDesired uint32) (key Handle, err error) {
4123 r0, _, e1 := syscall.SyscallN(procSetupDiOpenDevRegKey.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(Scope), uintptr(HwProfile), uintptr(KeyType), uintptr(samDesired))
4124 key = Handle(r0)
4125 if key == InvalidHandle {
4126 err = errnoErr(e1)
4127 }
4128 return
4129 }
4130
4131 func SetupDiSetClassInstallParams(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, classInstallParams *ClassInstallHeader, classInstallParamsSize uint32) (err error) {
4132 r1, _, e1 := syscall.SyscallN(procSetupDiSetClassInstallParamsW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(classInstallParams)), uintptr(classInstallParamsSize))
4133 if r1 == 0 {
4134 err = errnoErr(e1)
4135 }
4136 return
4137 }
4138
4139 func SetupDiSetDeviceInstallParams(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, deviceInstallParams *DevInstallParams) (err error) {
4140 r1, _, e1 := syscall.SyscallN(procSetupDiSetDeviceInstallParamsW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(deviceInstallParams)))
4141 if r1 == 0 {
4142 err = errnoErr(e1)
4143 }
4144 return
4145 }
4146
4147 func setupDiSetDeviceRegistryProperty(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, property SPDRP, propertyBuffer *byte, propertyBufferSize uint32) (err error) {
4148 r1, _, e1 := syscall.SyscallN(procSetupDiSetDeviceRegistryPropertyW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(property), uintptr(unsafe.Pointer(propertyBuffer)), uintptr(propertyBufferSize))
4149 if r1 == 0 {
4150 err = errnoErr(e1)
4151 }
4152 return
4153 }
4154
4155 func SetupDiSetSelectedDevice(deviceInfoSet DevInfo, deviceInfoData *DevInfoData) (err error) {
4156 r1, _, e1 := syscall.SyscallN(procSetupDiSetSelectedDevice.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)))
4157 if r1 == 0 {
4158 err = errnoErr(e1)
4159 }
4160 return
4161 }
4162
4163 func SetupDiSetSelectedDriver(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverInfoData *DrvInfoData) (err error) {
4164 r1, _, e1 := syscall.SyscallN(procSetupDiSetSelectedDriverW.Addr(), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(driverInfoData)))
4165 if r1 == 0 {
4166 err = errnoErr(e1)
4167 }
4168 return
4169 }
4170
4171 func setupUninstallOEMInf(infFileName *uint16, flags SUOI, reserved uintptr) (err error) {
4172 r1, _, e1 := syscall.SyscallN(procSetupUninstallOEMInfW.Addr(), uintptr(unsafe.Pointer(infFileName)), uintptr(flags), uintptr(reserved))
4173 if r1 == 0 {
4174 err = errnoErr(e1)
4175 }
4176 return
4177 }
4178
4179 func commandLineToArgv(cmd *uint16, argc *int32) (argv **uint16, err error) {
4180 r0, _, e1 := syscall.SyscallN(procCommandLineToArgvW.Addr(), uintptr(unsafe.Pointer(cmd)), uintptr(unsafe.Pointer(argc)))
4181 argv = (**uint16)(unsafe.Pointer(r0))
4182 if argv == nil {
4183 err = errnoErr(e1)
4184 }
4185 return
4186 }
4187
4188 func shGetKnownFolderPath(id *KNOWNFOLDERID, flags uint32, token Token, path **uint16) (ret error) {
4189 r0, _, _ := syscall.SyscallN(procSHGetKnownFolderPath.Addr(), uintptr(unsafe.Pointer(id)), uintptr(flags), uintptr(token), uintptr(unsafe.Pointer(path)))
4190 if r0 != 0 {
4191 ret = syscall.Errno(r0)
4192 }
4193 return
4194 }
4195
4196 func ShellExecute(hwnd Handle, verb *uint16, file *uint16, args *uint16, cwd *uint16, showCmd int32) (err error) {
4197 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))
4198 if r1 <= 32 {
4199 err = errnoErr(e1)
4200 }
4201 return
4202 }
4203
4204 func EnumChildWindows(hwnd HWND, enumFunc uintptr, param unsafe.Pointer) {
4205 syscall.SyscallN(procEnumChildWindows.Addr(), uintptr(hwnd), uintptr(enumFunc), uintptr(param))
4206 return
4207 }
4208
4209 func EnumWindows(enumFunc uintptr, param unsafe.Pointer) (err error) {
4210 r1, _, e1 := syscall.SyscallN(procEnumWindows.Addr(), uintptr(enumFunc), uintptr(param))
4211 if r1 == 0 {
4212 err = errnoErr(e1)
4213 }
4214 return
4215 }
4216
4217 func ExitWindowsEx(flags uint32, reason uint32) (err error) {
4218 r1, _, e1 := syscall.SyscallN(procExitWindowsEx.Addr(), uintptr(flags), uintptr(reason))
4219 if r1 == 0 {
4220 err = errnoErr(e1)
4221 }
4222 return
4223 }
4224
4225 func GetClassName(hwnd HWND, className *uint16, maxCount int32) (copied int32, err error) {
4226 r0, _, e1 := syscall.SyscallN(procGetClassNameW.Addr(), uintptr(hwnd), uintptr(unsafe.Pointer(className)), uintptr(maxCount))
4227 copied = int32(r0)
4228 if copied == 0 {
4229 err = errnoErr(e1)
4230 }
4231 return
4232 }
4233
4234 func GetDesktopWindow() (hwnd HWND) {
4235 r0, _, _ := syscall.SyscallN(procGetDesktopWindow.Addr())
4236 hwnd = HWND(r0)
4237 return
4238 }
4239
4240 func GetForegroundWindow() (hwnd HWND) {
4241 r0, _, _ := syscall.SyscallN(procGetForegroundWindow.Addr())
4242 hwnd = HWND(r0)
4243 return
4244 }
4245
4246 func GetGUIThreadInfo(thread uint32, info *GUIThreadInfo) (err error) {
4247 r1, _, e1 := syscall.SyscallN(procGetGUIThreadInfo.Addr(), uintptr(thread), uintptr(unsafe.Pointer(info)))
4248 if r1 == 0 {
4249 err = errnoErr(e1)
4250 }
4251 return
4252 }
4253
4254 func GetKeyboardLayout(tid uint32) (hkl Handle) {
4255 r0, _, _ := syscall.SyscallN(procGetKeyboardLayout.Addr(), uintptr(tid))
4256 hkl = Handle(r0)
4257 return
4258 }
4259
4260 func GetShellWindow() (shellWindow HWND) {
4261 r0, _, _ := syscall.SyscallN(procGetShellWindow.Addr())
4262 shellWindow = HWND(r0)
4263 return
4264 }
4265
4266 func GetWindowThreadProcessId(hwnd HWND, pid *uint32) (tid uint32, err error) {
4267 r0, _, e1 := syscall.SyscallN(procGetWindowThreadProcessId.Addr(), uintptr(hwnd), uintptr(unsafe.Pointer(pid)))
4268 tid = uint32(r0)
4269 if tid == 0 {
4270 err = errnoErr(e1)
4271 }
4272 return
4273 }
4274
4275 func IsWindow(hwnd HWND) (isWindow bool) {
4276 r0, _, _ := syscall.SyscallN(procIsWindow.Addr(), uintptr(hwnd))
4277 isWindow = r0 != 0
4278 return
4279 }
4280
4281 func IsWindowUnicode(hwnd HWND) (isUnicode bool) {
4282 r0, _, _ := syscall.SyscallN(procIsWindowUnicode.Addr(), uintptr(hwnd))
4283 isUnicode = r0 != 0
4284 return
4285 }
4286
4287 func IsWindowVisible(hwnd HWND) (isVisible bool) {
4288 r0, _, _ := syscall.SyscallN(procIsWindowVisible.Addr(), uintptr(hwnd))
4289 isVisible = r0 != 0
4290 return
4291 }
4292
4293 func LoadKeyboardLayout(name *uint16, flags uint32) (hkl Handle, err error) {
4294 r0, _, e1 := syscall.SyscallN(procLoadKeyboardLayoutW.Addr(), uintptr(unsafe.Pointer(name)), uintptr(flags))
4295 hkl = Handle(r0)
4296 if hkl == 0 {
4297 err = errnoErr(e1)
4298 }
4299 return
4300 }
4301
4302 func MessageBox(hwnd HWND, text *uint16, caption *uint16, boxtype uint32) (ret int32, err error) {
4303 r0, _, e1 := syscall.SyscallN(procMessageBoxW.Addr(), uintptr(hwnd), uintptr(unsafe.Pointer(text)), uintptr(unsafe.Pointer(caption)), uintptr(boxtype))
4304 ret = int32(r0)
4305 if ret == 0 {
4306 err = errnoErr(e1)
4307 }
4308 return
4309 }
4310
4311 func ToUnicodeEx(vkey uint32, scancode uint32, keystate *byte, pwszBuff *uint16, cchBuff int32, flags uint32, hkl Handle) (ret int32) {
4312 r0, _, _ := syscall.SyscallN(procToUnicodeEx.Addr(), uintptr(vkey), uintptr(scancode), uintptr(unsafe.Pointer(keystate)), uintptr(unsafe.Pointer(pwszBuff)), uintptr(cchBuff), uintptr(flags), uintptr(hkl))
4313 ret = int32(r0)
4314 return
4315 }
4316
4317 func UnloadKeyboardLayout(hkl Handle) (err error) {
4318 r1, _, e1 := syscall.SyscallN(procUnloadKeyboardLayout.Addr(), uintptr(hkl))
4319 if r1 == 0 {
4320 err = errnoErr(e1)
4321 }
4322 return
4323 }
4324
4325 func CreateEnvironmentBlock(block **uint16, token Token, inheritExisting bool) (err error) {
4326 var _p0 uint32
4327 if inheritExisting {
4328 _p0 = 1
4329 }
4330 r1, _, e1 := syscall.SyscallN(procCreateEnvironmentBlock.Addr(), uintptr(unsafe.Pointer(block)), uintptr(token), uintptr(_p0))
4331 if r1 == 0 {
4332 err = errnoErr(e1)
4333 }
4334 return
4335 }
4336
4337 func DestroyEnvironmentBlock(block *uint16) (err error) {
4338 r1, _, e1 := syscall.SyscallN(procDestroyEnvironmentBlock.Addr(), uintptr(unsafe.Pointer(block)))
4339 if r1 == 0 {
4340 err = errnoErr(e1)
4341 }
4342 return
4343 }
4344
4345 func GetUserProfileDirectory(t Token, dir *uint16, dirLen *uint32) (err error) {
4346 r1, _, e1 := syscall.SyscallN(procGetUserProfileDirectoryW.Addr(), uintptr(t), uintptr(unsafe.Pointer(dir)), uintptr(unsafe.Pointer(dirLen)))
4347 if r1 == 0 {
4348 err = errnoErr(e1)
4349 }
4350 return
4351 }
4352
4353 func GetFileVersionInfoSize(filename string, zeroHandle *Handle) (bufSize uint32, err error) {
4354 var _p0 *uint16
4355 _p0, err = syscall.UTF16PtrFromString(filename)
4356 if err != nil {
4357 return
4358 }
4359 return _GetFileVersionInfoSize(_p0, zeroHandle)
4360 }
4361
4362 func _GetFileVersionInfoSize(filename *uint16, zeroHandle *Handle) (bufSize uint32, err error) {
4363 r0, _, e1 := syscall.SyscallN(procGetFileVersionInfoSizeW.Addr(), uintptr(unsafe.Pointer(filename)), uintptr(unsafe.Pointer(zeroHandle)))
4364 bufSize = uint32(r0)
4365 if bufSize == 0 {
4366 err = errnoErr(e1)
4367 }
4368 return
4369 }
4370
4371 func GetFileVersionInfo(filename string, handle uint32, bufSize uint32, buffer unsafe.Pointer) (err error) {
4372 var _p0 *uint16
4373 _p0, err = syscall.UTF16PtrFromString(filename)
4374 if err != nil {
4375 return
4376 }
4377 return _GetFileVersionInfo(_p0, handle, bufSize, buffer)
4378 }
4379
4380 func _GetFileVersionInfo(filename *uint16, handle uint32, bufSize uint32, buffer unsafe.Pointer) (err error) {
4381 r1, _, e1 := syscall.SyscallN(procGetFileVersionInfoW.Addr(), uintptr(unsafe.Pointer(filename)), uintptr(handle), uintptr(bufSize), uintptr(buffer))
4382 if r1 == 0 {
4383 err = errnoErr(e1)
4384 }
4385 return
4386 }
4387
4388 func VerQueryValue(block unsafe.Pointer, subBlock string, pointerToBufferPointer unsafe.Pointer, bufSize *uint32) (err error) {
4389 var _p0 *uint16
4390 _p0, err = syscall.UTF16PtrFromString(subBlock)
4391 if err != nil {
4392 return
4393 }
4394 return _VerQueryValue(block, _p0, pointerToBufferPointer, bufSize)
4395 }
4396
4397 func _VerQueryValue(block unsafe.Pointer, subBlock *uint16, pointerToBufferPointer unsafe.Pointer, bufSize *uint32) (err error) {
4398 r1, _, e1 := syscall.SyscallN(procVerQueryValueW.Addr(), uintptr(block), uintptr(unsafe.Pointer(subBlock)), uintptr(pointerToBufferPointer), uintptr(unsafe.Pointer(bufSize)))
4399 if r1 == 0 {
4400 err = errnoErr(e1)
4401 }
4402 return
4403 }
4404
4405 func TimeBeginPeriod(period uint32) (err error) {
4406 r1, _, e1 := syscall.SyscallN(proctimeBeginPeriod.Addr(), uintptr(period))
4407 if r1 != 0 {
4408 err = errnoErr(e1)
4409 }
4410 return
4411 }
4412
4413 func TimeEndPeriod(period uint32) (err error) {
4414 r1, _, e1 := syscall.SyscallN(proctimeEndPeriod.Addr(), uintptr(period))
4415 if r1 != 0 {
4416 err = errnoErr(e1)
4417 }
4418 return
4419 }
4420
4421 func WinVerifyTrustEx(hwnd HWND, actionId *GUID, data *WinTrustData) (ret error) {
4422 r0, _, _ := syscall.SyscallN(procWinVerifyTrustEx.Addr(), uintptr(hwnd), uintptr(unsafe.Pointer(actionId)), uintptr(unsafe.Pointer(data)))
4423 if r0 != 0 {
4424 ret = syscall.Errno(r0)
4425 }
4426 return
4427 }
4428
4429 func FreeAddrInfoW(addrinfo *AddrinfoW) {
4430 syscall.SyscallN(procFreeAddrInfoW.Addr(), uintptr(unsafe.Pointer(addrinfo)))
4431 return
4432 }
4433
4434 func GetAddrInfoW(nodename *uint16, servicename *uint16, hints *AddrinfoW, result **AddrinfoW) (sockerr error) {
4435 r0, _, _ := syscall.SyscallN(procGetAddrInfoW.Addr(), uintptr(unsafe.Pointer(nodename)), uintptr(unsafe.Pointer(servicename)), uintptr(unsafe.Pointer(hints)), uintptr(unsafe.Pointer(result)))
4436 if r0 != 0 {
4437 sockerr = syscall.Errno(r0)
4438 }
4439 return
4440 }
4441
4442 func WSACleanup() (err error) {
4443 r1, _, e1 := syscall.SyscallN(procWSACleanup.Addr())
4444 if r1 == socket_error {
4445 err = errnoErr(e1)
4446 }
4447 return
4448 }
4449
4450 func WSADuplicateSocket(s Handle, processID uint32, info *WSAProtocolInfo) (err error) {
4451 r1, _, e1 := syscall.SyscallN(procWSADuplicateSocketW.Addr(), uintptr(s), uintptr(processID), uintptr(unsafe.Pointer(info)))
4452 if r1 != 0 {
4453 err = errnoErr(e1)
4454 }
4455 return
4456 }
4457
4458 func WSAEnumProtocols(protocols *int32, protocolBuffer *WSAProtocolInfo, bufferLength *uint32) (n int32, err error) {
4459 r0, _, e1 := syscall.SyscallN(procWSAEnumProtocolsW.Addr(), uintptr(unsafe.Pointer(protocols)), uintptr(unsafe.Pointer(protocolBuffer)), uintptr(unsafe.Pointer(bufferLength)))
4460 n = int32(r0)
4461 if n == -1 {
4462 err = errnoErr(e1)
4463 }
4464 return
4465 }
4466
4467 func WSAGetOverlappedResult(h Handle, o *Overlapped, bytes *uint32, wait bool, flags *uint32) (err error) {
4468 var _p0 uint32
4469 if wait {
4470 _p0 = 1
4471 }
4472 r1, _, e1 := syscall.SyscallN(procWSAGetOverlappedResult.Addr(), uintptr(h), uintptr(unsafe.Pointer(o)), uintptr(unsafe.Pointer(bytes)), uintptr(_p0), uintptr(unsafe.Pointer(flags)))
4473 if r1 == 0 {
4474 err = errnoErr(e1)
4475 }
4476 return
4477 }
4478
4479 func WSAIoctl(s Handle, iocc uint32, inbuf *byte, cbif uint32, outbuf *byte, cbob uint32, cbbr *uint32, overlapped *Overlapped, completionRoutine uintptr) (err error) {
4480 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))
4481 if r1 == socket_error {
4482 err = errnoErr(e1)
4483 }
4484 return
4485 }
4486
4487 func WSALookupServiceBegin(querySet *WSAQUERYSET, flags uint32, handle *Handle) (err error) {
4488 r1, _, e1 := syscall.SyscallN(procWSALookupServiceBeginW.Addr(), uintptr(unsafe.Pointer(querySet)), uintptr(flags), uintptr(unsafe.Pointer(handle)))
4489 if r1 == socket_error {
4490 err = errnoErr(e1)
4491 }
4492 return
4493 }
4494
4495 func WSALookupServiceEnd(handle Handle) (err error) {
4496 r1, _, e1 := syscall.SyscallN(procWSALookupServiceEnd.Addr(), uintptr(handle))
4497 if r1 == socket_error {
4498 err = errnoErr(e1)
4499 }
4500 return
4501 }
4502
4503 func WSALookupServiceNext(handle Handle, flags uint32, size *int32, querySet *WSAQUERYSET) (err error) {
4504 r1, _, e1 := syscall.SyscallN(procWSALookupServiceNextW.Addr(), uintptr(handle), uintptr(flags), uintptr(unsafe.Pointer(size)), uintptr(unsafe.Pointer(querySet)))
4505 if r1 == socket_error {
4506 err = errnoErr(e1)
4507 }
4508 return
4509 }
4510
4511 func WSARecv(s Handle, bufs *WSABuf, bufcnt uint32, recvd *uint32, flags *uint32, overlapped *Overlapped, croutine *byte) (err error) {
4512 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)))
4513 if r1 == socket_error {
4514 err = errnoErr(e1)
4515 }
4516 return
4517 }
4518
4519 func WSARecvFrom(s Handle, bufs *WSABuf, bufcnt uint32, recvd *uint32, flags *uint32, from *RawSockaddrAny, fromlen *int32, overlapped *Overlapped, croutine *byte) (err error) {
4520 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)))
4521 if r1 == socket_error {
4522 err = errnoErr(e1)
4523 }
4524 return
4525 }
4526
4527 func WSASend(s Handle, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, overlapped *Overlapped, croutine *byte) (err error) {
4528 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)))
4529 if r1 == socket_error {
4530 err = errnoErr(e1)
4531 }
4532 return
4533 }
4534
4535 func WSASendTo(s Handle, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, to *RawSockaddrAny, tolen int32, overlapped *Overlapped, croutine *byte) (err error) {
4536 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)))
4537 if r1 == socket_error {
4538 err = errnoErr(e1)
4539 }
4540 return
4541 }
4542
4543 func WSASocket(af int32, typ int32, protocol int32, protoInfo *WSAProtocolInfo, group uint32, flags uint32) (handle Handle, err error) {
4544 r0, _, e1 := syscall.SyscallN(procWSASocketW.Addr(), uintptr(af), uintptr(typ), uintptr(protocol), uintptr(unsafe.Pointer(protoInfo)), uintptr(group), uintptr(flags))
4545 handle = Handle(r0)
4546 if handle == InvalidHandle {
4547 err = errnoErr(e1)
4548 }
4549 return
4550 }
4551
4552 func WSAStartup(verreq uint32, data *WSAData) (sockerr error) {
4553 r0, _, _ := syscall.SyscallN(procWSAStartup.Addr(), uintptr(verreq), uintptr(unsafe.Pointer(data)))
4554 if r0 != 0 {
4555 sockerr = syscall.Errno(r0)
4556 }
4557 return
4558 }
4559
4560 func bind(s Handle, name unsafe.Pointer, namelen int32) (err error) {
4561 r1, _, e1 := syscall.SyscallN(procbind.Addr(), uintptr(s), uintptr(name), uintptr(namelen))
4562 if r1 == socket_error {
4563 err = errnoErr(e1)
4564 }
4565 return
4566 }
4567
4568 func Closesocket(s Handle) (err error) {
4569 r1, _, e1 := syscall.SyscallN(procclosesocket.Addr(), uintptr(s))
4570 if r1 == socket_error {
4571 err = errnoErr(e1)
4572 }
4573 return
4574 }
4575
4576 func connect(s Handle, name unsafe.Pointer, namelen int32) (err error) {
4577 r1, _, e1 := syscall.SyscallN(procconnect.Addr(), uintptr(s), uintptr(name), uintptr(namelen))
4578 if r1 == socket_error {
4579 err = errnoErr(e1)
4580 }
4581 return
4582 }
4583
4584 func GetHostByName(name string) (h *Hostent, err error) {
4585 var _p0 *byte
4586 _p0, err = syscall.BytePtrFromString(name)
4587 if err != nil {
4588 return
4589 }
4590 return _GetHostByName(_p0)
4591 }
4592
4593 func _GetHostByName(name *byte) (h *Hostent, err error) {
4594 r0, _, e1 := syscall.SyscallN(procgethostbyname.Addr(), uintptr(unsafe.Pointer(name)))
4595 h = (*Hostent)(unsafe.Pointer(r0))
4596 if h == nil {
4597 err = errnoErr(e1)
4598 }
4599 return
4600 }
4601
4602 func getpeername(s Handle, rsa *RawSockaddrAny, addrlen *int32) (err error) {
4603 r1, _, e1 := syscall.SyscallN(procgetpeername.Addr(), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
4604 if r1 == socket_error {
4605 err = errnoErr(e1)
4606 }
4607 return
4608 }
4609
4610 func GetProtoByName(name string) (p *Protoent, err error) {
4611 var _p0 *byte
4612 _p0, err = syscall.BytePtrFromString(name)
4613 if err != nil {
4614 return
4615 }
4616 return _GetProtoByName(_p0)
4617 }
4618
4619 func _GetProtoByName(name *byte) (p *Protoent, err error) {
4620 r0, _, e1 := syscall.SyscallN(procgetprotobyname.Addr(), uintptr(unsafe.Pointer(name)))
4621 p = (*Protoent)(unsafe.Pointer(r0))
4622 if p == nil {
4623 err = errnoErr(e1)
4624 }
4625 return
4626 }
4627
4628 func GetServByName(name string, proto string) (s *Servent, err error) {
4629 var _p0 *byte
4630 _p0, err = syscall.BytePtrFromString(name)
4631 if err != nil {
4632 return
4633 }
4634 var _p1 *byte
4635 _p1, err = syscall.BytePtrFromString(proto)
4636 if err != nil {
4637 return
4638 }
4639 return _GetServByName(_p0, _p1)
4640 }
4641
4642 func _GetServByName(name *byte, proto *byte) (s *Servent, err error) {
4643 r0, _, e1 := syscall.SyscallN(procgetservbyname.Addr(), uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(proto)))
4644 s = (*Servent)(unsafe.Pointer(r0))
4645 if s == nil {
4646 err = errnoErr(e1)
4647 }
4648 return
4649 }
4650
4651 func getsockname(s Handle, rsa *RawSockaddrAny, addrlen *int32) (err error) {
4652 r1, _, e1 := syscall.SyscallN(procgetsockname.Addr(), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
4653 if r1 == socket_error {
4654 err = errnoErr(e1)
4655 }
4656 return
4657 }
4658
4659 func Getsockopt(s Handle, level int32, optname int32, optval *byte, optlen *int32) (err error) {
4660 r1, _, e1 := syscall.SyscallN(procgetsockopt.Addr(), uintptr(s), uintptr(level), uintptr(optname), uintptr(unsafe.Pointer(optval)), uintptr(unsafe.Pointer(optlen)))
4661 if r1 == socket_error {
4662 err = errnoErr(e1)
4663 }
4664 return
4665 }
4666
4667 func listen(s Handle, backlog int32) (err error) {
4668 r1, _, e1 := syscall.SyscallN(proclisten.Addr(), uintptr(s), uintptr(backlog))
4669 if r1 == socket_error {
4670 err = errnoErr(e1)
4671 }
4672 return
4673 }
4674
4675 func Ntohs(netshort uint16) (u uint16) {
4676 r0, _, _ := syscall.SyscallN(procntohs.Addr(), uintptr(netshort))
4677 u = uint16(r0)
4678 return
4679 }
4680
4681 func recvfrom(s Handle, buf []byte, flags int32, from *RawSockaddrAny, fromlen *int32) (n int32, err error) {
4682 var _p0 *byte
4683 if len(buf) > 0 {
4684 _p0 = &buf[0]
4685 }
4686 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)))
4687 n = int32(r0)
4688 if n == -1 {
4689 err = errnoErr(e1)
4690 }
4691 return
4692 }
4693
4694 func sendto(s Handle, buf []byte, flags int32, to unsafe.Pointer, tolen int32) (err error) {
4695 var _p0 *byte
4696 if len(buf) > 0 {
4697 _p0 = &buf[0]
4698 }
4699 r1, _, e1 := syscall.SyscallN(procsendto.Addr(), uintptr(s), uintptr(unsafe.Pointer(_p0)), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(tolen))
4700 if r1 == socket_error {
4701 err = errnoErr(e1)
4702 }
4703 return
4704 }
4705
4706 func Setsockopt(s Handle, level int32, optname int32, optval *byte, optlen int32) (err error) {
4707 r1, _, e1 := syscall.SyscallN(procsetsockopt.Addr(), uintptr(s), uintptr(level), uintptr(optname), uintptr(unsafe.Pointer(optval)), uintptr(optlen))
4708 if r1 == socket_error {
4709 err = errnoErr(e1)
4710 }
4711 return
4712 }
4713
4714 func shutdown(s Handle, how int32) (err error) {
4715 r1, _, e1 := syscall.SyscallN(procshutdown.Addr(), uintptr(s), uintptr(how))
4716 if r1 == socket_error {
4717 err = errnoErr(e1)
4718 }
4719 return
4720 }
4721
4722 func socket(af int32, typ int32, protocol int32) (handle Handle, err error) {
4723 r0, _, e1 := syscall.SyscallN(procsocket.Addr(), uintptr(af), uintptr(typ), uintptr(protocol))
4724 handle = Handle(r0)
4725 if handle == InvalidHandle {
4726 err = errnoErr(e1)
4727 }
4728 return
4729 }
4730
4731 func WTSEnumerateSessions(handle Handle, reserved uint32, version uint32, sessions **WTS_SESSION_INFO, count *uint32) (err error) {
4732 r1, _, e1 := syscall.SyscallN(procWTSEnumerateSessionsW.Addr(), uintptr(handle), uintptr(reserved), uintptr(version), uintptr(unsafe.Pointer(sessions)), uintptr(unsafe.Pointer(count)))
4733 if r1 == 0 {
4734 err = errnoErr(e1)
4735 }
4736 return
4737 }
4738
4739 func WTSFreeMemory(ptr uintptr) {
4740 syscall.SyscallN(procWTSFreeMemory.Addr(), uintptr(ptr))
4741 return
4742 }
4743
4744 func WTSQueryUserToken(session uint32, token *Token) (err error) {
4745 r1, _, e1 := syscall.SyscallN(procWTSQueryUserToken.Addr(), uintptr(session), uintptr(unsafe.Pointer(token)))
4746 if r1 == 0 {
4747 err = errnoErr(e1)
4748 }
4749 return
4750 }
4751
View as plain text