.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/sys@v0.0.0-20210124154548-22da62e12c0c/windows/syscall_windows.go

   1 // Copyright 2009 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // Windows system calls.
   6
   7 package windows
   8
   9 import (
  10         errorspkg "errors"
  11         "sync"
  12         "syscall"
  13         "time"
  14         "unicode/utf16"
  15         "unsafe"
  16
  17         "golang.org/x/sys/internal/unsafeheader"
  18 )
  19
  20 type Handle uintptr
  21 type HWND uintptr
  22
  23 const (
  24         InvalidHandle = ^Handle(0)
  25         InvalidHWND   = ^HWND(0)
  26
  27         // Flags for DefineDosDevice.
  28         DDD_EXACT_MATCH_ON_REMOVE = 0x00000004
  29         DDD_NO_BROADCAST_SYSTEM   = 0x00000008
  30         DDD_RAW_TARGET_PATH       = 0x00000001
  31         DDD_REMOVE_DEFINITION     = 0x00000002
  32
  33         // Return values for GetDriveType.
  34         DRIVE_UNKNOWN     = 0
  35         DRIVE_NO_ROOT_DIR = 1
  36         DRIVE_REMOVABLE   = 2
  37         DRIVE_FIXED       = 3
  38         DRIVE_REMOTE      = 4
  39         DRIVE_CDROM       = 5
  40         DRIVE_RAMDISK     = 6
  41
  42         // File system flags from GetVolumeInformation and GetVolumeInformationByHandle.
  43         FILE_CASE_SENSITIVE_SEARCH        = 0x00000001
  44         FILE_CASE_PRESERVED_NAMES         = 0x00000002
  45         FILE_FILE_COMPRESSION             = 0x00000010
  46         FILE_DAX_VOLUME                   = 0x20000000
  47         FILE_NAMED_STREAMS                = 0x00040000
  48         FILE_PERSISTENT_ACLS              = 0x00000008
  49         FILE_READ_ONLY_VOLUME             = 0x00080000
  50         FILE_SEQUENTIAL_WRITE_ONCE        = 0x00100000
  51         FILE_SUPPORTS_ENCRYPTION          = 0x00020000
  52         FILE_SUPPORTS_EXTENDED_ATTRIBUTES = 0x00800000
  53         FILE_SUPPORTS_HARD_LINKS          = 0x00400000
  54         FILE_SUPPORTS_OBJECT_IDS          = 0x00010000
  55         FILE_SUPPORTS_OPEN_BY_FILE_ID     = 0x01000000
  56         FILE_SUPPORTS_REPARSE_POINTS      = 0x00000080
  57         FILE_SUPPORTS_SPARSE_FILES        = 0x00000040
  58         FILE_SUPPORTS_TRANSACTIONS        = 0x00200000
  59         FILE_SUPPORTS_USN_JOURNAL         = 0x02000000
  60         FILE_UNICODE_ON_DISK              = 0x00000004
  61         FILE_VOLUME_IS_COMPRESSED         = 0x00008000
  62         FILE_VOLUME_QUOTAS                = 0x00000020
  63
  64         // Flags for LockFileEx.
  65         LOCKFILE_FAIL_IMMEDIATELY = 0x00000001
  66         LOCKFILE_EXCLUSIVE_LOCK   = 0x00000002
  67
  68         // Return values of SleepEx and other APC functions
  69         STATUS_USER_APC    = 0x000000C0
  70         WAIT_IO_COMPLETION = STATUS_USER_APC
  71 )
  72
  73 // StringToUTF16 is deprecated. Use UTF16FromString instead.
  74 // If s contains a NUL byte this function panics instead of
  75 // returning an error.
  76 func StringToUTF16(s string) []uint16 {
  77         a, err := UTF16FromString(s)
  78         if err != nil {
  79                 panic("windows: string with NUL passed to StringToUTF16")
  80         }
  81         return a
  82 }
  83
  84 // UTF16FromString returns the UTF-16 encoding of the UTF-8 string
  85 // s, with a terminating NUL added. If s contains a NUL byte at any
  86 // location, it returns (nil, syscall.EINVAL).
  87 func UTF16FromString(s string) ([]uint16, error) {
  88         for i := 0; i < len(s); i++ {
  89                 if s[i] == 0 {
  90                         return nil, syscall.EINVAL
  91                 }
  92         }
  93         return utf16.Encode([]rune(s + "\x00")), nil
  94 }
  95
  96 // UTF16ToString returns the UTF-8 encoding of the UTF-16 sequence s,
  97 // with a terminating NUL and any bytes after the NUL removed.
  98 func UTF16ToString(s []uint16) string {
  99         for i, v := range s {
 100                 if v == 0 {
 101                         s = s[:i]
 102                         break
 103                 }
 104         }
 105         return string(utf16.Decode(s))
 106 }
 107
 108 // StringToUTF16Ptr is deprecated. Use UTF16PtrFromString instead.
 109 // If s contains a NUL byte this function panics instead of
 110 // returning an error.
 111 func StringToUTF16Ptr(s string) *uint16 { return &StringToUTF16(s)[0] }
 112
 113 // UTF16PtrFromString returns pointer to the UTF-16 encoding of
 114 // the UTF-8 string s, with a terminating NUL added. If s
 115 // contains a NUL byte at any location, it returns (nil, syscall.EINVAL).
 116 func UTF16PtrFromString(s string) (*uint16, error) {
 117         a, err := UTF16FromString(s)
 118         if err != nil {
 119                 return nil, err
 120         }
 121         return &a[0], nil
 122 }
 123
 124 // UTF16PtrToString takes a pointer to a UTF-16 sequence and returns the corresponding UTF-8 encoded string.
 125 // If the pointer is nil, it returns the empty string. It assumes that the UTF-16 sequence is terminated
 126 // at a zero word; if the zero word is not present, the program may crash.
 127 func UTF16PtrToString(p *uint16) string {
 128         if p == nil {
 129                 return ""
 130         }
 131         if *p == 0 {
 132                 return ""
 133         }
 134
 135         // Find NUL terminator.
 136         n := 0
 137         for ptr := unsafe.Pointer(p); *(*uint16)(ptr) != 0; n++ {
 138                 ptr = unsafe.Pointer(uintptr(ptr) + unsafe.Sizeof(*p))
 139         }
 140
 141         var s []uint16
 142         h := (*unsafeheader.Slice)(unsafe.Pointer(&s))
 143         h.Data = unsafe.Pointer(p)
 144         h.Len = n
 145         h.Cap = n
 146
 147         return string(utf16.Decode(s))
 148 }
 149
 150 func Getpagesize() int { return 4096 }
 151
 152 // NewCallback converts a Go function to a function pointer conforming to the stdcall calling convention.
 153 // This is useful when interoperating with Windows code requiring callbacks.
 154 // The argument is expected to be a function with with one uintptr-sized result. The function must not have arguments with size larger than the size of uintptr.
 155 func NewCallback(fn interface{}) uintptr {
 156         return syscall.NewCallback(fn)
 157 }
 158
 159 // NewCallbackCDecl converts a Go function to a function pointer conforming to the cdecl calling convention.
 160 // This is useful when interoperating with Windows code requiring callbacks.
 161 // The argument is expected to be a function with with one uintptr-sized result. The function must not have arguments with size larger than the size of uintptr.
 162 func NewCallbackCDecl(fn interface{}) uintptr {
 163         return syscall.NewCallbackCDecl(fn)
 164 }
 165
 166 // windows api calls
 167
 168 //sys   GetLastError() (lasterr error)
 169 //sys   LoadLibrary(libname string) (handle Handle, err error) = LoadLibraryW
 170 //sys   LoadLibraryEx(libname string, zero Handle, flags uintptr) (handle Handle, err error) = LoadLibraryExW
 171 //sys   FreeLibrary(handle Handle) (err error)
 172 //sys   GetProcAddress(module Handle, procname string) (proc uintptr, err error)
 173 //sys   GetModuleFileName(module Handle, filename *uint16, size uint32) (n uint32, err error) = kernel32.GetModuleFileNameW
 174 //sys   GetModuleHandleEx(flags uint32, moduleName *uint16, module *Handle) (err error) = kernel32.GetModuleHandleExW
 175 //sys   SetDefaultDllDirectories(directoryFlags uint32) (err error)
 176 //sys   SetDllDirectory(path string) (err error) = kernel32.SetDllDirectoryW
 177 //sys   GetVersion() (ver uint32, err error)
 178 //sys   FormatMessage(flags uint32, msgsrc uintptr, msgid uint32, langid uint32, buf []uint16, args *byte) (n uint32, err error) = FormatMessageW
 179 //sys   ExitProcess(exitcode uint32)
 180 //sys   IsWow64Process(handle Handle, isWow64 *bool) (err error) = IsWow64Process
 181 //sys   IsWow64Process2(handle Handle, processMachine *uint16, nativeMachine *uint16) (err error) = IsWow64Process2?
 182 //sys   CreateFile(name *uint16, access uint32, mode uint32, sa *SecurityAttributes, createmode uint32, attrs uint32, templatefile Handle) (handle Handle, err error) [failretval==InvalidHandle] = CreateFileW
 183 //sys   ReadFile(handle Handle, buf []byte, done *uint32, overlapped *Overlapped) (err error)
 184 //sys   WriteFile(handle Handle, buf []byte, done *uint32, overlapped *Overlapped) (err error)
 185 //sys   GetOverlappedResult(handle Handle, overlapped *Overlapped, done *uint32, wait bool) (err error)
 186 //sys   SetFilePointer(handle Handle, lowoffset int32, highoffsetptr *int32, whence uint32) (newlowoffset uint32, err error) [failretval==0xffffffff]
 187 //sys   CloseHandle(handle Handle) (err error)
 188 //sys   GetStdHandle(stdhandle uint32) (handle Handle, err error) [failretval==InvalidHandle]
 189 //sys   SetStdHandle(stdhandle uint32, handle Handle) (err error)
 190 //sys   findFirstFile1(name *uint16, data *win32finddata1) (handle Handle, err error) [failretval==InvalidHandle] = FindFirstFileW
 191 //sys   findNextFile1(handle Handle, data *win32finddata1) (err error) = FindNextFileW
 192 //sys   FindClose(handle Handle) (err error)
 193 //sys   GetFileInformationByHandle(handle Handle, data *ByHandleFileInformation) (err error)
 194 //sys   GetFileInformationByHandleEx(handle Handle, class uint32, outBuffer *byte, outBufferLen uint32) (err error)
 195 //sys   SetFileInformationByHandle(handle Handle, class uint32, inBuffer *byte, inBufferLen uint32) (err error)
 196 //sys   GetCurrentDirectory(buflen uint32, buf *uint16) (n uint32, err error) = GetCurrentDirectoryW
 197 //sys   SetCurrentDirectory(path *uint16) (err error) = SetCurrentDirectoryW
 198 //sys   CreateDirectory(path *uint16, sa *SecurityAttributes) (err error) = CreateDirectoryW
 199 //sys   RemoveDirectory(path *uint16) (err error) = RemoveDirectoryW
 200 //sys   DeleteFile(path *uint16) (err error) = DeleteFileW
 201 //sys   MoveFile(from *uint16, to *uint16) (err error) = MoveFileW
 202 //sys   MoveFileEx(from *uint16, to *uint16, flags uint32) (err error) = MoveFileExW
 203 //sys   LockFileEx(file Handle, flags uint32, reserved uint32, bytesLow uint32, bytesHigh uint32, overlapped *Overlapped) (err error)
 204 //sys   UnlockFileEx(file Handle, reserved uint32, bytesLow uint32, bytesHigh uint32, overlapped *Overlapped) (err error)
 205 //sys   GetComputerName(buf *uint16, n *uint32) (err error) = GetComputerNameW
 206 //sys   GetComputerNameEx(nametype uint32, buf *uint16, n *uint32) (err error) = GetComputerNameExW
 207 //sys   SetEndOfFile(handle Handle) (err error)
 208 //sys   GetSystemTimeAsFileTime(time *Filetime)
 209 //sys   GetSystemTimePreciseAsFileTime(time *Filetime)
 210 //sys   GetTimeZoneInformation(tzi *Timezoneinformation) (rc uint32, err error) [failretval==0xffffffff]
 211 //sys   CreateIoCompletionPort(filehandle Handle, cphandle Handle, key uint32, threadcnt uint32) (handle Handle, err error)
 212 //sys   GetQueuedCompletionStatus(cphandle Handle, qty *uint32, key *uint32, overlapped **Overlapped, timeout uint32) (err error)
 213 //sys   PostQueuedCompletionStatus(cphandle Handle, qty uint32, key uint32, overlapped *Overlapped) (err error)
 214 //sys   CancelIo(s Handle) (err error)
 215 //sys   CancelIoEx(s Handle, o *Overlapped) (err error)
 216 //sys   CreateProcess(appName *uint16, commandLine *uint16, procSecurity *SecurityAttributes, threadSecurity *SecurityAttributes, inheritHandles bool, creationFlags uint32, env *uint16, currentDir *uint16, startupInfo *StartupInfo, outProcInfo *ProcessInformation) (err error) = CreateProcessW
 217 //sys   OpenProcess(desiredAccess uint32, inheritHandle bool, processId uint32) (handle Handle, err error)
 218 //sys   ShellExecute(hwnd Handle, verb *uint16, file *uint16, args *uint16, cwd *uint16, showCmd int32) (err error) [failretval<=32] = shell32.ShellExecuteW
 219 //sys   GetWindowThreadProcessId(hwnd HWND, pid *uint32) (tid uint32, err error) = user32.GetWindowThreadProcessId
 220 //sys   GetShellWindow() (shellWindow HWND) = user32.GetShellWindow
 221 //sys   MessageBox(hwnd HWND, text *uint16, caption *uint16, boxtype uint32) (ret int32, err error) [failretval==0] = user32.MessageBoxW
 222 //sys   ExitWindowsEx(flags uint32, reason uint32) (err error) = user32.ExitWindowsEx
 223 //sys   shGetKnownFolderPath(id *KNOWNFOLDERID, flags uint32, token Token, path **uint16) (ret error) = shell32.SHGetKnownFolderPath
 224 //sys   TerminateProcess(handle Handle, exitcode uint32) (err error)
 225 //sys   GetExitCodeProcess(handle Handle, exitcode *uint32) (err error)
 226 //sys   GetStartupInfo(startupInfo *StartupInfo) (err error) = GetStartupInfoW
 227 //sys   GetProcessTimes(handle Handle, creationTime *Filetime, exitTime *Filetime, kernelTime *Filetime, userTime *Filetime) (err error)
 228 //sys   DuplicateHandle(hSourceProcessHandle Handle, hSourceHandle Handle, hTargetProcessHandle Handle, lpTargetHandle *Handle, dwDesiredAccess uint32, bInheritHandle bool, dwOptions uint32) (err error)
 229 //sys   WaitForSingleObject(handle Handle, waitMilliseconds uint32) (event uint32, err error) [failretval==0xffffffff]
 230 //sys   waitForMultipleObjects(count uint32, handles uintptr, waitAll bool, waitMilliseconds uint32) (event uint32, err error) [failretval==0xffffffff] = WaitForMultipleObjects
 231 //sys   GetTempPath(buflen uint32, buf *uint16) (n uint32, err error) = GetTempPathW
 232 //sys   CreatePipe(readhandle *Handle, writehandle *Handle, sa *SecurityAttributes, size uint32) (err error)
 233 //sys   GetFileType(filehandle Handle) (n uint32, err error)
 234 //sys   CryptAcquireContext(provhandle *Handle, container *uint16, provider *uint16, provtype uint32, flags uint32) (err error) = advapi32.CryptAcquireContextW
 235 //sys   CryptReleaseContext(provhandle Handle, flags uint32) (err error) = advapi32.CryptReleaseContext
 236 //sys   CryptGenRandom(provhandle Handle, buflen uint32, buf *byte) (err error) = advapi32.CryptGenRandom
 237 //sys   GetEnvironmentStrings() (envs *uint16, err error) [failretval==nil] = kernel32.GetEnvironmentStringsW
 238 //sys   FreeEnvironmentStrings(envs *uint16) (err error) = kernel32.FreeEnvironmentStringsW
 239 //sys   GetEnvironmentVariable(name *uint16, buffer *uint16, size uint32) (n uint32, err error) = kernel32.GetEnvironmentVariableW
 240 //sys   SetEnvironmentVariable(name *uint16, value *uint16) (err error) = kernel32.SetEnvironmentVariableW
 241 //sys   CreateEnvironmentBlock(block **uint16, token Token, inheritExisting bool) (err error) = userenv.CreateEnvironmentBlock
 242 //sys   DestroyEnvironmentBlock(block *uint16) (err error) = userenv.DestroyEnvironmentBlock
 243 //sys   getTickCount64() (ms uint64) = kernel32.GetTickCount64
 244 //sys   SetFileTime(handle Handle, ctime *Filetime, atime *Filetime, wtime *Filetime) (err error)
 245 //sys   GetFileAttributes(name *uint16) (attrs uint32, err error) [failretval==INVALID_FILE_ATTRIBUTES] = kernel32.GetFileAttributesW
 246 //sys   SetFileAttributes(name *uint16, attrs uint32) (err error) = kernel32.SetFileAttributesW
 247 //sys   GetFileAttributesEx(name *uint16, level uint32, info *byte) (err error) = kernel32.GetFileAttributesExW
 248 //sys   GetCommandLine() (cmd *uint16) = kernel32.GetCommandLineW
 249 //sys   CommandLineToArgv(cmd *uint16, argc *int32) (argv *[8192]*[8192]uint16, err error) [failretval==nil] = shell32.CommandLineToArgvW
 250 //sys   LocalFree(hmem Handle) (handle Handle, err error) [failretval!=0]
 251 //sys   SetHandleInformation(handle Handle, mask uint32, flags uint32) (err error)
 252 //sys   FlushFileBuffers(handle Handle) (err error)
 253 //sys   GetFullPathName(path *uint16, buflen uint32, buf *uint16, fname **uint16) (n uint32, err error) = kernel32.GetFullPathNameW
 254 //sys   GetLongPathName(path *uint16, buf *uint16, buflen uint32) (n uint32, err error) = kernel32.GetLongPathNameW
 255 //sys   GetShortPathName(longpath *uint16, shortpath *uint16, buflen uint32) (n uint32, err error) = kernel32.GetShortPathNameW
 256 //sys   GetFinalPathNameByHandle(file Handle, filePath *uint16, filePathSize uint32, flags uint32) (n uint32, err error) = kernel32.GetFinalPathNameByHandleW
 257 //sys   CreateFileMapping(fhandle Handle, sa *SecurityAttributes, prot uint32, maxSizeHigh uint32, maxSizeLow uint32, name *uint16) (handle Handle, err error) = kernel32.CreateFileMappingW
 258 //sys   MapViewOfFile(handle Handle, access uint32, offsetHigh uint32, offsetLow uint32, length uintptr) (addr uintptr, err error)
 259 //sys   UnmapViewOfFile(addr uintptr) (err error)
 260 //sys   FlushViewOfFile(addr uintptr, length uintptr) (err error)
 261 //sys   VirtualLock(addr uintptr, length uintptr) (err error)
 262 //sys   VirtualUnlock(addr uintptr, length uintptr) (err error)
 263 //sys   VirtualAlloc(address uintptr, size uintptr, alloctype uint32, protect uint32) (value uintptr, err error) = kernel32.VirtualAlloc
 264 //sys   VirtualFree(address uintptr, size uintptr, freetype uint32) (err error) = kernel32.VirtualFree
 265 //sys   VirtualProtect(address uintptr, size uintptr, newprotect uint32, oldprotect *uint32) (err error) = kernel32.VirtualProtect
 266 //sys   TransmitFile(s Handle, handle Handle, bytesToWrite uint32, bytsPerSend uint32, overlapped *Overlapped, transmitFileBuf *TransmitFileBuffers, flags uint32) (err error) = mswsock.TransmitFile
 267 //sys   ReadDirectoryChanges(handle Handle, buf *byte, buflen uint32, watchSubTree bool, mask uint32, retlen *uint32, overlapped *Overlapped, completionRoutine uintptr) (err error) = kernel32.ReadDirectoryChangesW
 268 //sys   FindFirstChangeNotification(path string, watchSubtree bool, notifyFilter uint32) (handle Handle, err error) [failretval==InvalidHandle] = kernel32.FindFirstChangeNotificationW
 269 //sys   FindNextChangeNotification(handle Handle) (err error)
 270 //sys   FindCloseChangeNotification(handle Handle) (err error)
 271 //sys   CertOpenSystemStore(hprov Handle, name *uint16) (store Handle, err error) = crypt32.CertOpenSystemStoreW
 272 //sys   CertOpenStore(storeProvider uintptr, msgAndCertEncodingType uint32, cryptProv uintptr, flags uint32, para uintptr) (handle Handle, err error) = crypt32.CertOpenStore
 273 //sys   CertEnumCertificatesInStore(store Handle, prevContext *CertContext) (context *CertContext, err error) [failretval==nil] = crypt32.CertEnumCertificatesInStore
 274 //sys   CertAddCertificateContextToStore(store Handle, certContext *CertContext, addDisposition uint32, storeContext **CertContext) (err error) = crypt32.CertAddCertificateContextToStore
 275 //sys   CertCloseStore(store Handle, flags uint32) (err error) = crypt32.CertCloseStore
 276 //sys   CertDeleteCertificateFromStore(certContext *CertContext) (err error) = crypt32.CertDeleteCertificateFromStore
 277 //sys   CertDuplicateCertificateContext(certContext *CertContext) (dupContext *CertContext) = crypt32.CertDuplicateCertificateContext
 278 //sys   PFXImportCertStore(pfx *CryptDataBlob, password *uint16, flags uint32) (store Handle, err error) = crypt32.PFXImportCertStore
 279 //sys   CertGetCertificateChain(engine Handle, leaf *CertContext, time *Filetime, additionalStore Handle, para *CertChainPara, flags uint32, reserved uintptr, chainCtx **CertChainContext) (err error) = crypt32.CertGetCertificateChain
 280 //sys   CertFreeCertificateChain(ctx *CertChainContext) = crypt32.CertFreeCertificateChain
 281 //sys   CertCreateCertificateContext(certEncodingType uint32, certEncoded *byte, encodedLen uint32) (context *CertContext, err error) [failretval==nil] = crypt32.CertCreateCertificateContext
 282 //sys   CertFreeCertificateContext(ctx *CertContext) (err error) = crypt32.CertFreeCertificateContext
 283 //sys   CertVerifyCertificateChainPolicy(policyOID uintptr, chain *CertChainContext, para *CertChainPolicyPara, status *CertChainPolicyStatus) (err error) = crypt32.CertVerifyCertificateChainPolicy
 284 //sys   CertGetNameString(certContext *CertContext, nameType uint32, flags uint32, typePara unsafe.Pointer, name *uint16, size uint32) (chars uint32) = crypt32.CertGetNameStringW
 285 //sys   CertFindExtension(objId *byte, countExtensions uint32, extensions *CertExtension) (ret *CertExtension) = crypt32.CertFindExtension
 286 //sys   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) = crypt32.CryptQueryObject
 287 //sys   CryptDecodeObject(encodingType uint32, structType *byte, encodedBytes *byte, lenEncodedBytes uint32, flags uint32, decoded unsafe.Pointer, decodedLen *uint32) (err error) = crypt32.CryptDecodeObject
 288 //sys   CryptProtectData(dataIn *DataBlob, name *uint16, optionalEntropy *DataBlob, reserved uintptr, promptStruct *CryptProtectPromptStruct, flags uint32, dataOut *DataBlob) (err error) = crypt32.CryptProtectData
 289 //sys   CryptUnprotectData(dataIn *DataBlob, name **uint16, optionalEntropy *DataBlob, reserved uintptr, promptStruct *CryptProtectPromptStruct, flags uint32, dataOut *DataBlob) (err error) = crypt32.CryptUnprotectData
 290 //sys   WinVerifyTrustEx(hwnd HWND, actionId *GUID, data *WinTrustData) (ret error) = wintrust.WinVerifyTrustEx
 291 //sys   RegOpenKeyEx(key Handle, subkey *uint16, options uint32, desiredAccess uint32, result *Handle) (regerrno error) = advapi32.RegOpenKeyExW
 292 //sys   RegCloseKey(key Handle) (regerrno error) = advapi32.RegCloseKey
 293 //sys   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) = advapi32.RegQueryInfoKeyW
 294 //sys   RegEnumKeyEx(key Handle, index uint32, name *uint16, nameLen *uint32, reserved *uint32, class *uint16, classLen *uint32, lastWriteTime *Filetime) (regerrno error) = advapi32.RegEnumKeyExW
 295 //sys   RegQueryValueEx(key Handle, name *uint16, reserved *uint32, valtype *uint32, buf *byte, buflen *uint32) (regerrno error) = advapi32.RegQueryValueExW
 296 //sys   RegNotifyChangeKeyValue(key Handle, watchSubtree bool, notifyFilter uint32, event Handle, asynchronous bool) (regerrno error) = advapi32.RegNotifyChangeKeyValue
 297 //sys   GetCurrentProcessId() (pid uint32) = kernel32.GetCurrentProcessId
 298 //sys   ProcessIdToSessionId(pid uint32, sessionid *uint32) (err error) = kernel32.ProcessIdToSessionId
 299 //sys   GetConsoleMode(console Handle, mode *uint32) (err error) = kernel32.GetConsoleMode
 300 //sys   SetConsoleMode(console Handle, mode uint32) (err error) = kernel32.SetConsoleMode
 301 //sys   GetConsoleScreenBufferInfo(console Handle, info *ConsoleScreenBufferInfo) (err error) = kernel32.GetConsoleScreenBufferInfo
 302 //sys   setConsoleCursorPosition(console Handle, position uint32) (err error) = kernel32.SetConsoleCursorPosition
 303 //sys   WriteConsole(console Handle, buf *uint16, towrite uint32, written *uint32, reserved *byte) (err error) = kernel32.WriteConsoleW
 304 //sys   ReadConsole(console Handle, buf *uint16, toread uint32, read *uint32, inputControl *byte) (err error) = kernel32.ReadConsoleW
 305 //sys   CreateToolhelp32Snapshot(flags uint32, processId uint32) (handle Handle, err error) [failretval==InvalidHandle] = kernel32.CreateToolhelp32Snapshot
 306 //sys   Process32First(snapshot Handle, procEntry *ProcessEntry32) (err error) = kernel32.Process32FirstW
 307 //sys   Process32Next(snapshot Handle, procEntry *ProcessEntry32) (err error) = kernel32.Process32NextW
 308 //sys   Thread32First(snapshot Handle, threadEntry *ThreadEntry32) (err error)
 309 //sys   Thread32Next(snapshot Handle, threadEntry *ThreadEntry32) (err error)
 310 //sys   DeviceIoControl(handle Handle, ioControlCode uint32, inBuffer *byte, inBufferSize uint32, outBuffer *byte, outBufferSize uint32, bytesReturned *uint32, overlapped *Overlapped) (err error)
 311 // This function returns 1 byte BOOLEAN rather than the 4 byte BOOL.
 312 //sys   CreateSymbolicLink(symlinkfilename *uint16, targetfilename *uint16, flags uint32) (err error) [failretval&0xff==0] = CreateSymbolicLinkW
 313 //sys   CreateHardLink(filename *uint16, existingfilename *uint16, reserved uintptr) (err error) [failretval&0xff==0] = CreateHardLinkW
 314 //sys   GetCurrentThreadId() (id uint32)
 315 //sys   CreateEvent(eventAttrs *SecurityAttributes, manualReset uint32, initialState uint32, name *uint16) (handle Handle, err error) = kernel32.CreateEventW
 316 //sys   CreateEventEx(eventAttrs *SecurityAttributes, name *uint16, flags uint32, desiredAccess uint32) (handle Handle, err error) = kernel32.CreateEventExW
 317 //sys   OpenEvent(desiredAccess uint32, inheritHandle bool, name *uint16) (handle Handle, err error) = kernel32.OpenEventW
 318 //sys   SetEvent(event Handle) (err error) = kernel32.SetEvent
 319 //sys   ResetEvent(event Handle) (err error) = kernel32.ResetEvent
 320 //sys   PulseEvent(event Handle) (err error) = kernel32.PulseEvent
 321 //sys   CreateMutex(mutexAttrs *SecurityAttributes, initialOwner bool, name *uint16) (handle Handle, err error) = kernel32.CreateMutexW
 322 //sys   CreateMutexEx(mutexAttrs *SecurityAttributes, name *uint16, flags uint32, desiredAccess uint32) (handle Handle, err error) = kernel32.CreateMutexExW
 323 //sys   OpenMutex(desiredAccess uint32, inheritHandle bool, name *uint16) (handle Handle, err error) = kernel32.OpenMutexW
 324 //sys   ReleaseMutex(mutex Handle) (err error) = kernel32.ReleaseMutex
 325 //sys   SleepEx(milliseconds uint32, alertable bool) (ret uint32) = kernel32.SleepEx
 326 //sys   CreateJobObject(jobAttr *SecurityAttributes, name *uint16) (handle Handle, err error) = kernel32.CreateJobObjectW
 327 //sys   AssignProcessToJobObject(job Handle, process Handle) (err error) = kernel32.AssignProcessToJobObject
 328 //sys   TerminateJobObject(job Handle, exitCode uint32) (err error) = kernel32.TerminateJobObject
 329 //sys   SetErrorMode(mode uint32) (ret uint32) = kernel32.SetErrorMode
 330 //sys   ResumeThread(thread Handle) (ret uint32, err error) [failretval==0xffffffff] = kernel32.ResumeThread
 331 //sys   SetPriorityClass(process Handle, priorityClass uint32) (err error) = kernel32.SetPriorityClass
 332 //sys   GetPriorityClass(process Handle) (ret uint32, err error) = kernel32.GetPriorityClass
 333 //sys   QueryInformationJobObject(job Handle, JobObjectInformationClass int32, JobObjectInformation uintptr, JobObjectInformationLength uint32, retlen *uint32) (err error) = kernel32.QueryInformationJobObject
 334 //sys   SetInformationJobObject(job Handle, JobObjectInformationClass uint32, JobObjectInformation uintptr, JobObjectInformationLength uint32) (ret int, err error)
 335 //sys   GenerateConsoleCtrlEvent(ctrlEvent uint32, processGroupID uint32) (err error)
 336 //sys   GetProcessId(process Handle) (id uint32, err error)
 337 //sys   OpenThread(desiredAccess uint32, inheritHandle bool, threadId uint32) (handle Handle, err error)
 338 //sys   SetProcessPriorityBoost(process Handle, disable bool) (err error) = kernel32.SetProcessPriorityBoost
 339 //sys   GetProcessWorkingSetSizeEx(hProcess Handle, lpMinimumWorkingSetSize *uintptr, lpMaximumWorkingSetSize *uintptr, flags *uint32)
 340 //sys   SetProcessWorkingSetSizeEx(hProcess Handle, dwMinimumWorkingSetSize uintptr, dwMaximumWorkingSetSize uintptr, flags uint32) (err error)
 341
 342 // Volume Management Functions
 343 //sys   DefineDosDevice(flags uint32, deviceName *uint16, targetPath *uint16) (err error) = DefineDosDeviceW
 344 //sys   DeleteVolumeMountPoint(volumeMountPoint *uint16) (err error) = DeleteVolumeMountPointW
 345 //sys   FindFirstVolume(volumeName *uint16, bufferLength uint32) (handle Handle, err error) [failretval==InvalidHandle] = FindFirstVolumeW
 346 //sys   FindFirstVolumeMountPoint(rootPathName *uint16, volumeMountPoint *uint16, bufferLength uint32) (handle Handle, err error) [failretval==InvalidHandle] = FindFirstVolumeMountPointW
 347 //sys   FindNextVolume(findVolume Handle, volumeName *uint16, bufferLength uint32) (err error) = FindNextVolumeW
 348 //sys   FindNextVolumeMountPoint(findVolumeMountPoint Handle, volumeMountPoint *uint16, bufferLength uint32) (err error) = FindNextVolumeMountPointW
 349 //sys   FindVolumeClose(findVolume Handle) (err error)
 350 //sys   FindVolumeMountPointClose(findVolumeMountPoint Handle) (err error)
 351 //sys   GetDiskFreeSpaceEx(directoryName *uint16, freeBytesAvailableToCaller *uint64, totalNumberOfBytes *uint64, totalNumberOfFreeBytes *uint64) (err error) = GetDiskFreeSpaceExW
 352 //sys   GetDriveType(rootPathName *uint16) (driveType uint32) = GetDriveTypeW
 353 //sys   GetLogicalDrives() (drivesBitMask uint32, err error) [failretval==0]
 354 //sys   GetLogicalDriveStrings(bufferLength uint32, buffer *uint16) (n uint32, err error) [failretval==0] = GetLogicalDriveStringsW
 355 //sys   GetVolumeInformation(rootPathName *uint16, volumeNameBuffer *uint16, volumeNameSize uint32, volumeNameSerialNumber *uint32, maximumComponentLength *uint32, fileSystemFlags *uint32, fileSystemNameBuffer *uint16, fileSystemNameSize uint32) (err error) = GetVolumeInformationW
 356 //sys   GetVolumeInformationByHandle(file Handle, volumeNameBuffer *uint16, volumeNameSize uint32, volumeNameSerialNumber *uint32, maximumComponentLength *uint32, fileSystemFlags *uint32, fileSystemNameBuffer *uint16, fileSystemNameSize uint32) (err error) = GetVolumeInformationByHandleW
 357 //sys   GetVolumeNameForVolumeMountPoint(volumeMountPoint *uint16, volumeName *uint16, bufferlength uint32) (err error) = GetVolumeNameForVolumeMountPointW
 358 //sys   GetVolumePathName(fileName *uint16, volumePathName *uint16, bufferLength uint32) (err error) = GetVolumePathNameW
 359 //sys   GetVolumePathNamesForVolumeName(volumeName *uint16, volumePathNames *uint16, bufferLength uint32, returnLength *uint32) (err error) = GetVolumePathNamesForVolumeNameW
 360 //sys   QueryDosDevice(deviceName *uint16, targetPath *uint16, max uint32) (n uint32, err error) [failretval==0] = QueryDosDeviceW
 361 //sys   SetVolumeLabel(rootPathName *uint16, volumeName *uint16) (err error) = SetVolumeLabelW
 362 //sys   SetVolumeMountPoint(volumeMountPoint *uint16, volumeName *uint16) (err error) = SetVolumeMountPointW
 363 //sys   InitiateSystemShutdownEx(machineName *uint16, message *uint16, timeout uint32, forceAppsClosed bool, rebootAfterShutdown bool, reason uint32) (err error) = advapi32.InitiateSystemShutdownExW
 364 //sys   SetProcessShutdownParameters(level uint32, flags uint32) (err error) = kernel32.SetProcessShutdownParameters
 365 //sys   GetProcessShutdownParameters(level *uint32, flags *uint32) (err error) = kernel32.GetProcessShutdownParameters
 366 //sys   clsidFromString(lpsz *uint16, pclsid *GUID) (ret error) = ole32.CLSIDFromString
 367 //sys   stringFromGUID2(rguid *GUID, lpsz *uint16, cchMax int32) (chars int32) = ole32.StringFromGUID2
 368 //sys   coCreateGuid(pguid *GUID) (ret error) = ole32.CoCreateGuid
 369 //sys   CoTaskMemFree(address unsafe.Pointer) = ole32.CoTaskMemFree
 370 //sys   rtlGetVersion(info *OsVersionInfoEx) (ret error) = ntdll.RtlGetVersion
 371 //sys   rtlGetNtVersionNumbers(majorVersion *uint32, minorVersion *uint32, buildNumber *uint32) = ntdll.RtlGetNtVersionNumbers
 372 //sys   getProcessPreferredUILanguages(flags uint32, numLanguages *uint32, buf *uint16, bufSize *uint32) (err error) = kernel32.GetProcessPreferredUILanguages
 373 //sys   getThreadPreferredUILanguages(flags uint32, numLanguages *uint32, buf *uint16, bufSize *uint32) (err error) = kernel32.GetThreadPreferredUILanguages
 374 //sys   getUserPreferredUILanguages(flags uint32, numLanguages *uint32, buf *uint16, bufSize *uint32) (err error) = kernel32.GetUserPreferredUILanguages
 375 //sys   getSystemPreferredUILanguages(flags uint32, numLanguages *uint32, buf *uint16, bufSize *uint32) (err error) = kernel32.GetSystemPreferredUILanguages
 376
 377 // Process Status API (PSAPI)
 378 //sys   EnumProcesses(processIds []uint32, bytesReturned *uint32) (err error) = psapi.EnumProcesses
 379
 380 // syscall interface implementation for other packages
 381
 382 // GetCurrentProcess returns the handle for the current process.
 383 // It is a pseudo handle that does not need to be closed.
 384 // The returned error is always nil.
 385 //
 386 // Deprecated: use CurrentProcess for the same Handle without the nil
 387 // error.
 388 func GetCurrentProcess() (Handle, error) {
 389         return CurrentProcess(), nil
 390 }
 391
 392 // CurrentProcess returns the handle for the current process.
 393 // It is a pseudo handle that does not need to be closed.
 394 func CurrentProcess() Handle { return Handle(^uintptr(1 - 1)) }
 395
 396 // GetCurrentThread returns the handle for the current thread.
 397 // It is a pseudo handle that does not need to be closed.
 398 // The returned error is always nil.
 399 //
 400 // Deprecated: use CurrentThread for the same Handle without the nil
 401 // error.
 402 func GetCurrentThread() (Handle, error) {
 403         return CurrentThread(), nil
 404 }
 405
 406 // CurrentThread returns the handle for the current thread.
 407 // It is a pseudo handle that does not need to be closed.
 408 func CurrentThread() Handle { return Handle(^uintptr(2 - 1)) }
 409
 410 // GetProcAddressByOrdinal retrieves the address of the exported
 411 // function from module by ordinal.
 412 func GetProcAddressByOrdinal(module Handle, ordinal uintptr) (proc uintptr, err error) {
 413         r0, _, e1 := syscall.Syscall(procGetProcAddress.Addr(), 2, uintptr(module), ordinal, 0)
 414         proc = uintptr(r0)
 415         if proc == 0 {
 416                 err = errnoErr(e1)
 417         }
 418         return
 419 }
 420
 421 func Exit(code int) { ExitProcess(uint32(code)) }
 422
 423 func makeInheritSa() *SecurityAttributes {
 424         var sa SecurityAttributes
 425         sa.Length = uint32(unsafe.Sizeof(sa))
 426         sa.InheritHandle = 1
 427         return &sa
 428 }
 429
 430 func Open(path string, mode int, perm uint32) (fd Handle, err error) {
 431         if len(path) == 0 {
 432                 return InvalidHandle, ERROR_FILE_NOT_FOUND
 433         }
 434         pathp, err := UTF16PtrFromString(path)
 435         if err != nil {
 436                 return InvalidHandle, err
 437         }
 438         var access uint32
 439         switch mode & (O_RDONLY | O_WRONLY | O_RDWR) {
 440         case O_RDONLY:
 441                 access = GENERIC_READ
 442         case O_WRONLY:
 443                 access = GENERIC_WRITE
 444         case O_RDWR:
 445                 access = GENERIC_READ | GENERIC_WRITE
 446         }
 447         if mode&O_CREAT != 0 {
 448                 access |= GENERIC_WRITE
 449         }
 450         if mode&O_APPEND != 0 {
 451                 access &^= GENERIC_WRITE
 452                 access |= FILE_APPEND_DATA
 453         }
 454         sharemode := uint32(FILE_SHARE_READ | FILE_SHARE_WRITE)
 455         var sa *SecurityAttributes
 456         if mode&O_CLOEXEC == 0 {
 457                 sa = makeInheritSa()
 458         }
 459         var createmode uint32
 460         switch {
 461         case mode&(O_CREAT|O_EXCL) == (O_CREAT | O_EXCL):
 462                 createmode = CREATE_NEW
 463         case mode&(O_CREAT|O_TRUNC) == (O_CREAT | O_TRUNC):
 464                 createmode = CREATE_ALWAYS
 465         case mode&O_CREAT == O_CREAT:
 466                 createmode = OPEN_ALWAYS
 467         case mode&O_TRUNC == O_TRUNC:
 468                 createmode = TRUNCATE_EXISTING
 469         default:
 470                 createmode = OPEN_EXISTING
 471         }
 472         var attrs uint32 = FILE_ATTRIBUTE_NORMAL
 473         if perm&S_IWRITE == 0 {
 474                 attrs = FILE_ATTRIBUTE_READONLY
 475         }
 476         h, e := CreateFile(pathp, access, sharemode, sa, createmode, attrs, 0)
 477         return h, e
 478 }
 479
 480 func Read(fd Handle, p []byte) (n int, err error) {
 481         var done uint32
 482         e := ReadFile(fd, p, &done, nil)
 483         if e != nil {
 484                 if e == ERROR_BROKEN_PIPE {
 485                         // NOTE(brainman): work around ERROR_BROKEN_PIPE is returned on reading EOF from stdin
 486                         return 0, nil
 487                 }
 488                 return 0, e
 489         }
 490         if raceenabled {
 491                 if done > 0 {
 492                         raceWriteRange(unsafe.Pointer(&p[0]), int(done))
 493                 }
 494                 raceAcquire(unsafe.Pointer(&ioSync))
 495         }
 496         return int(done), nil
 497 }
 498
 499 func Write(fd Handle, p []byte) (n int, err error) {
 500         if raceenabled {
 501                 raceReleaseMerge(unsafe.Pointer(&ioSync))
 502         }
 503         var done uint32
 504         e := WriteFile(fd, p, &done, nil)
 505         if e != nil {
 506                 return 0, e
 507         }
 508         if raceenabled && done > 0 {
 509                 raceReadRange(unsafe.Pointer(&p[0]), int(done))
 510         }
 511         return int(done), nil
 512 }
 513
 514 var ioSync int64
 515
 516 func Seek(fd Handle, offset int64, whence int) (newoffset int64, err error) {
 517         var w uint32
 518         switch whence {
 519         case 0:
 520                 w = FILE_BEGIN
 521         case 1:
 522                 w = FILE_CURRENT
 523         case 2:
 524                 w = FILE_END
 525         }
 526         hi := int32(offset >> 32)
 527         lo := int32(offset)
 528         // use GetFileType to check pipe, pipe can't do seek
 529         ft, _ := GetFileType(fd)
 530         if ft == FILE_TYPE_PIPE {
 531                 return 0, syscall.EPIPE
 532         }
 533         rlo, e := SetFilePointer(fd, lo, &hi, w)
 534         if e != nil {
 535                 return 0, e
 536         }
 537         return int64(hi)<<32 + int64(rlo), nil
 538 }
 539
 540 func Close(fd Handle) (err error) {
 541         return CloseHandle(fd)
 542 }
 543
 544 var (
 545         Stdin  = getStdHandle(STD_INPUT_HANDLE)
 546         Stdout = getStdHandle(STD_OUTPUT_HANDLE)
 547         Stderr = getStdHandle(STD_ERROR_HANDLE)
 548 )
 549
 550 func getStdHandle(stdhandle uint32) (fd Handle) {
 551         r, _ := GetStdHandle(stdhandle)
 552         CloseOnExec(r)
 553         return r
 554 }
 555
 556 const ImplementsGetwd = true
 557
 558 func Getwd() (wd string, err error) {
 559         b := make([]uint16, 300)
 560         n, e := GetCurrentDirectory(uint32(len(b)), &b[0])
 561         if e != nil {
 562                 return "", e
 563         }
 564         return string(utf16.Decode(b[0:n])), nil
 565 }
 566
 567 func Chdir(path string) (err error) {
 568         pathp, err := UTF16PtrFromString(path)
 569         if err != nil {
 570                 return err
 571         }
 572         return SetCurrentDirectory(pathp)
 573 }
 574
 575 func Mkdir(path string, mode uint32) (err error) {
 576         pathp, err := UTF16PtrFromString(path)
 577         if err != nil {
 578                 return err
 579         }
 580         return CreateDirectory(pathp, nil)
 581 }
 582
 583 func Rmdir(path string) (err error) {
 584         pathp, err := UTF16PtrFromString(path)
 585         if err != nil {
 586                 return err
 587         }
 588         return RemoveDirectory(pathp)
 589 }
 590
 591 func Unlink(path string) (err error) {
 592         pathp, err := UTF16PtrFromString(path)
 593         if err != nil {
 594                 return err
 595         }
 596         return DeleteFile(pathp)
 597 }
 598
 599 func Rename(oldpath, newpath string) (err error) {
 600         from, err := UTF16PtrFromString(oldpath)
 601         if err != nil {
 602                 return err
 603         }
 604         to, err := UTF16PtrFromString(newpath)
 605         if err != nil {
 606                 return err
 607         }
 608         return MoveFileEx(from, to, MOVEFILE_REPLACE_EXISTING)
 609 }
 610
 611 func ComputerName() (name string, err error) {
 612         var n uint32 = MAX_COMPUTERNAME_LENGTH + 1
 613         b := make([]uint16, n)
 614         e := GetComputerName(&b[0], &n)
 615         if e != nil {
 616                 return "", e
 617         }
 618         return string(utf16.Decode(b[0:n])), nil
 619 }
 620
 621 func DurationSinceBoot() time.Duration {
 622         return time.Duration(getTickCount64()) * time.Millisecond
 623 }
 624
 625 func Ftruncate(fd Handle, length int64) (err error) {
 626         curoffset, e := Seek(fd, 0, 1)
 627         if e != nil {
 628                 return e
 629         }
 630         defer Seek(fd, curoffset, 0)
 631         _, e = Seek(fd, length, 0)
 632         if e != nil {
 633                 return e
 634         }
 635         e = SetEndOfFile(fd)
 636         if e != nil {
 637                 return e
 638         }
 639         return nil
 640 }
 641
 642 func Gettimeofday(tv *Timeval) (err error) {
 643         var ft Filetime
 644         GetSystemTimeAsFileTime(&ft)
 645         *tv = NsecToTimeval(ft.Nanoseconds())
 646         return nil
 647 }
 648
 649 func Pipe(p []Handle) (err error) {
 650         if len(p) != 2 {
 651                 return syscall.EINVAL
 652         }
 653         var r, w Handle
 654         e := CreatePipe(&r, &w, makeInheritSa(), 0)
 655         if e != nil {
 656                 return e
 657         }
 658         p[0] = r
 659         p[1] = w
 660         return nil
 661 }
 662
 663 func Utimes(path string, tv []Timeval) (err error) {
 664         if len(tv) != 2 {
 665                 return syscall.EINVAL
 666         }
 667         pathp, e := UTF16PtrFromString(path)
 668         if e != nil {
 669                 return e
 670         }
 671         h, e := CreateFile(pathp,
 672                 FILE_WRITE_ATTRIBUTES, FILE_SHARE_WRITE, nil,
 673                 OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0)
 674         if e != nil {
 675                 return e
 676         }
 677         defer Close(h)
 678         a := NsecToFiletime(tv[0].Nanoseconds())
 679         w := NsecToFiletime(tv[1].Nanoseconds())
 680         return SetFileTime(h, nil, &a, &w)
 681 }
 682
 683 func UtimesNano(path string, ts []Timespec) (err error) {
 684         if len(ts) != 2 {
 685                 return syscall.EINVAL
 686         }
 687         pathp, e := UTF16PtrFromString(path)
 688         if e != nil {
 689                 return e
 690         }
 691         h, e := CreateFile(pathp,
 692                 FILE_WRITE_ATTRIBUTES, FILE_SHARE_WRITE, nil,
 693                 OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0)
 694         if e != nil {
 695                 return e
 696         }
 697         defer Close(h)
 698         a := NsecToFiletime(TimespecToNsec(ts[0]))
 699         w := NsecToFiletime(TimespecToNsec(ts[1]))
 700         return SetFileTime(h, nil, &a, &w)
 701 }
 702
 703 func Fsync(fd Handle) (err error) {
 704         return FlushFileBuffers(fd)
 705 }
 706
 707 func Chmod(path string, mode uint32) (err error) {
 708         p, e := UTF16PtrFromString(path)
 709         if e != nil {
 710                 return e
 711         }
 712         attrs, e := GetFileAttributes(p)
 713         if e != nil {
 714                 return e
 715         }
 716         if mode&S_IWRITE != 0 {
 717                 attrs &^= FILE_ATTRIBUTE_READONLY
 718         } else {
 719                 attrs |= FILE_ATTRIBUTE_READONLY
 720         }
 721         return SetFileAttributes(p, attrs)
 722 }
 723
 724 func LoadGetSystemTimePreciseAsFileTime() error {
 725         return procGetSystemTimePreciseAsFileTime.Find()
 726 }
 727
 728 func LoadCancelIoEx() error {
 729         return procCancelIoEx.Find()
 730 }
 731
 732 func LoadSetFileCompletionNotificationModes() error {
 733         return procSetFileCompletionNotificationModes.Find()
 734 }
 735
 736 func WaitForMultipleObjects(handles []Handle, waitAll bool, waitMilliseconds uint32) (event uint32, err error) {
 737         // Every other win32 array API takes arguments as "pointer, count", except for this function. So we
 738         // can't declare it as a usual [] type, because mksyscall will use the opposite order. We therefore
 739         // trivially stub this ourselves.
 740
 741         var handlePtr *Handle
 742         if len(handles) > 0 {
 743                 handlePtr = &handles[0]
 744         }
 745         return waitForMultipleObjects(uint32(len(handles)), uintptr(unsafe.Pointer(handlePtr)), waitAll, waitMilliseconds)
 746 }
 747
 748 // net api calls
 749
 750 const socket_error = uintptr(^uint32(0))
 751
 752 //sys   WSAStartup(verreq uint32, data *WSAData) (sockerr error) = ws2_32.WSAStartup
 753 //sys   WSACleanup() (err error) [failretval==socket_error] = ws2_32.WSACleanup
 754 //sys   WSAIoctl(s Handle, iocc uint32, inbuf *byte, cbif uint32, outbuf *byte, cbob uint32, cbbr *uint32, overlapped *Overlapped, completionRoutine uintptr) (err error) [failretval==socket_error] = ws2_32.WSAIoctl
 755 //sys   socket(af int32, typ int32, protocol int32) (handle Handle, err error) [failretval==InvalidHandle] = ws2_32.socket
 756 //sys   sendto(s Handle, buf []byte, flags int32, to unsafe.Pointer, tolen int32) (err error) [failretval==socket_error] = ws2_32.sendto
 757 //sys   recvfrom(s Handle, buf []byte, flags int32, from *RawSockaddrAny, fromlen *int32) (n int32, err error) [failretval==-1] = ws2_32.recvfrom
 758 //sys   Setsockopt(s Handle, level int32, optname int32, optval *byte, optlen int32) (err error) [failretval==socket_error] = ws2_32.setsockopt
 759 //sys   Getsockopt(s Handle, level int32, optname int32, optval *byte, optlen *int32) (err error) [failretval==socket_error] = ws2_32.getsockopt
 760 //sys   bind(s Handle, name unsafe.Pointer, namelen int32) (err error) [failretval==socket_error] = ws2_32.bind
 761 //sys   connect(s Handle, name unsafe.Pointer, namelen int32) (err error) [failretval==socket_error] = ws2_32.connect
 762 //sys   getsockname(s Handle, rsa *RawSockaddrAny, addrlen *int32) (err error) [failretval==socket_error] = ws2_32.getsockname
 763 //sys   getpeername(s Handle, rsa *RawSockaddrAny, addrlen *int32) (err error) [failretval==socket_error] = ws2_32.getpeername
 764 //sys   listen(s Handle, backlog int32) (err error) [failretval==socket_error] = ws2_32.listen
 765 //sys   shutdown(s Handle, how int32) (err error) [failretval==socket_error] = ws2_32.shutdown
 766 //sys   Closesocket(s Handle) (err error) [failretval==socket_error] = ws2_32.closesocket
 767 //sys   AcceptEx(ls Handle, as Handle, buf *byte, rxdatalen uint32, laddrlen uint32, raddrlen uint32, recvd *uint32, overlapped *Overlapped) (err error) = mswsock.AcceptEx
 768 //sys   GetAcceptExSockaddrs(buf *byte, rxdatalen uint32, laddrlen uint32, raddrlen uint32, lrsa **RawSockaddrAny, lrsalen *int32, rrsa **RawSockaddrAny, rrsalen *int32) = mswsock.GetAcceptExSockaddrs
 769 //sys   WSARecv(s Handle, bufs *WSABuf, bufcnt uint32, recvd *uint32, flags *uint32, overlapped *Overlapped, croutine *byte) (err error) [failretval==socket_error] = ws2_32.WSARecv
 770 //sys   WSASend(s Handle, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, overlapped *Overlapped, croutine *byte) (err error) [failretval==socket_error] = ws2_32.WSASend
 771 //sys   WSARecvFrom(s Handle, bufs *WSABuf, bufcnt uint32, recvd *uint32, flags *uint32,  from *RawSockaddrAny, fromlen *int32, overlapped *Overlapped, croutine *byte) (err error) [failretval==socket_error] = ws2_32.WSARecvFrom
 772 //sys   WSASendTo(s Handle, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, to *RawSockaddrAny, tolen int32,  overlapped *Overlapped, croutine *byte) (err error) [failretval==socket_error] = ws2_32.WSASendTo
 773 //sys   GetHostByName(name string) (h *Hostent, err error) [failretval==nil] = ws2_32.gethostbyname
 774 //sys   GetServByName(name string, proto string) (s *Servent, err error) [failretval==nil] = ws2_32.getservbyname
 775 //sys   Ntohs(netshort uint16) (u uint16) = ws2_32.ntohs
 776 //sys   GetProtoByName(name string) (p *Protoent, err error) [failretval==nil] = ws2_32.getprotobyname
 777 //sys   DnsQuery(name string, qtype uint16, options uint32, extra *byte, qrs **DNSRecord, pr *byte) (status error) = dnsapi.DnsQuery_W
 778 //sys   DnsRecordListFree(rl *DNSRecord, freetype uint32) = dnsapi.DnsRecordListFree
 779 //sys   DnsNameCompare(name1 *uint16, name2 *uint16) (same bool) = dnsapi.DnsNameCompare_W
 780 //sys   GetAddrInfoW(nodename *uint16, servicename *uint16, hints *AddrinfoW, result **AddrinfoW) (sockerr error) = ws2_32.GetAddrInfoW
 781 //sys   FreeAddrInfoW(addrinfo *AddrinfoW) = ws2_32.FreeAddrInfoW
 782 //sys   GetIfEntry(pIfRow *MibIfRow) (errcode error) = iphlpapi.GetIfEntry
 783 //sys   GetAdaptersInfo(ai *IpAdapterInfo, ol *uint32) (errcode error) = iphlpapi.GetAdaptersInfo
 784 //sys   SetFileCompletionNotificationModes(handle Handle, flags uint8) (err error) = kernel32.SetFileCompletionNotificationModes
 785 //sys   WSAEnumProtocols(protocols *int32, protocolBuffer *WSAProtocolInfo, bufferLength *uint32) (n int32, err error) [failretval==-1] = ws2_32.WSAEnumProtocolsW
 786 //sys   GetAdaptersAddresses(family uint32, flags uint32, reserved uintptr, adapterAddresses *IpAdapterAddresses, sizePointer *uint32) (errcode error) = iphlpapi.GetAdaptersAddresses
 787 //sys   GetACP() (acp uint32) = kernel32.GetACP
 788 //sys   MultiByteToWideChar(codePage uint32, dwFlags uint32, str *byte, nstr int32, wchar *uint16, nwchar int32) (nwrite int32, err error) = kernel32.MultiByteToWideChar
 789
 790 // For testing: clients can set this flag to force
 791 // creation of IPv6 sockets to return EAFNOSUPPORT.
 792 var SocketDisableIPv6 bool
 793
 794 type RawSockaddrInet4 struct {
 795         Family uint16
 796         Port   uint16
 797         Addr   [4]byte /* in_addr */
 798         Zero   [8]uint8
 799 }
 800
 801 type RawSockaddrInet6 struct {
 802         Family   uint16
 803         Port     uint16
 804         Flowinfo uint32
 805         Addr     [16]byte /* in6_addr */
 806         Scope_id uint32
 807 }
 808
 809 type RawSockaddr struct {
 810         Family uint16
 811         Data   [14]int8
 812 }
 813
 814 type RawSockaddrAny struct {
 815         Addr RawSockaddr
 816         Pad  [100]int8
 817 }
 818
 819 type Sockaddr interface {
 820         sockaddr() (ptr unsafe.Pointer, len int32, err error) // lowercase; only we can define Sockaddrs
 821 }
 822
 823 type SockaddrInet4 struct {
 824         Port int
 825         Addr [4]byte
 826         raw  RawSockaddrInet4
 827 }
 828
 829 func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, int32, error) {
 830         if sa.Port < 0 || sa.Port > 0xFFFF {
 831                 return nil, 0, syscall.EINVAL
 832         }
 833         sa.raw.Family = AF_INET
 834         p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
 835         p[0] = byte(sa.Port >> 8)
 836         p[1] = byte(sa.Port)
 837         for i := 0; i < len(sa.Addr); i++ {
 838                 sa.raw.Addr[i] = sa.Addr[i]
 839         }
 840         return unsafe.Pointer(&sa.raw), int32(unsafe.Sizeof(sa.raw)), nil
 841 }
 842
 843 type SockaddrInet6 struct {
 844         Port   int
 845         ZoneId uint32
 846         Addr   [16]byte
 847         raw    RawSockaddrInet6
 848 }
 849
 850 func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, int32, error) {
 851         if sa.Port < 0 || sa.Port > 0xFFFF {
 852                 return nil, 0, syscall.EINVAL
 853         }
 854         sa.raw.Family = AF_INET6
 855         p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
 856         p[0] = byte(sa.Port >> 8)
 857         p[1] = byte(sa.Port)
 858         sa.raw.Scope_id = sa.ZoneId
 859         for i := 0; i < len(sa.Addr); i++ {
 860                 sa.raw.Addr[i] = sa.Addr[i]
 861         }
 862         return unsafe.Pointer(&sa.raw), int32(unsafe.Sizeof(sa.raw)), nil
 863 }
 864
 865 type RawSockaddrUnix struct {
 866         Family uint16
 867         Path   [UNIX_PATH_MAX]int8
 868 }
 869
 870 type SockaddrUnix struct {
 871         Name string
 872         raw  RawSockaddrUnix
 873 }
 874
 875 func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, int32, error) {
 876         name := sa.Name
 877         n := len(name)
 878         if n > len(sa.raw.Path) {
 879                 return nil, 0, syscall.EINVAL
 880         }
 881         if n == len(sa.raw.Path) && name[0] != '@' {
 882                 return nil, 0, syscall.EINVAL
 883         }
 884         sa.raw.Family = AF_UNIX
 885         for i := 0; i < n; i++ {
 886                 sa.raw.Path[i] = int8(name[i])
 887         }
 888         // length is family (uint16), name, NUL.
 889         sl := int32(2)
 890         if n > 0 {
 891                 sl += int32(n) + 1
 892         }
 893         if sa.raw.Path[0] == '@' {
 894                 sa.raw.Path[0] = 0
 895                 // Don't count trailing NUL for abstract address.
 896                 sl--
 897         }
 898
 899         return unsafe.Pointer(&sa.raw), sl, nil
 900 }
 901
 902 func (rsa *RawSockaddrAny) Sockaddr() (Sockaddr, error) {
 903         switch rsa.Addr.Family {
 904         case AF_UNIX:
 905                 pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
 906                 sa := new(SockaddrUnix)
 907                 if pp.Path[0] == 0 {
 908                         // "Abstract" Unix domain socket.
 909                         // Rewrite leading NUL as @ for textual display.
 910                         // (This is the standard convention.)
 911                         // Not friendly to overwrite in place,
 912                         // but the callers below don't care.
 913                         pp.Path[0] = '@'
 914                 }
 915
 916                 // Assume path ends at NUL.
 917                 // This is not technically the Linux semantics for
 918                 // abstract Unix domain sockets--they are supposed
 919                 // to be uninterpreted fixed-size binary blobs--but
 920                 // everyone uses this convention.
 921                 n := 0
 922                 for n < len(pp.Path) && pp.Path[n] != 0 {
 923                         n++
 924                 }
 925                 bytes := (*[len(pp.Path)]byte)(unsafe.Pointer(&pp.Path[0]))[0:n]
 926                 sa.Name = string(bytes)
 927                 return sa, nil
 928
 929         case AF_INET:
 930                 pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa))
 931                 sa := new(SockaddrInet4)
 932                 p := (*[2]byte)(unsafe.Pointer(&pp.Port))
 933                 sa.Port = int(p[0])<<8 + int(p[1])
 934                 for i := 0; i < len(sa.Addr); i++ {
 935                         sa.Addr[i] = pp.Addr[i]
 936                 }
 937                 return sa, nil
 938
 939         case AF_INET6:
 940                 pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa))
 941                 sa := new(SockaddrInet6)
 942                 p := (*[2]byte)(unsafe.Pointer(&pp.Port))
 943                 sa.Port = int(p[0])<<8 + int(p[1])
 944                 sa.ZoneId = pp.Scope_id
 945                 for i := 0; i < len(sa.Addr); i++ {
 946                         sa.Addr[i] = pp.Addr[i]
 947                 }
 948                 return sa, nil
 949         }
 950         return nil, syscall.EAFNOSUPPORT
 951 }
 952
 953 func Socket(domain, typ, proto int) (fd Handle, err error) {
 954         if domain == AF_INET6 && SocketDisableIPv6 {
 955                 return InvalidHandle, syscall.EAFNOSUPPORT
 956         }
 957         return socket(int32(domain), int32(typ), int32(proto))
 958 }
 959
 960 func SetsockoptInt(fd Handle, level, opt int, value int) (err error) {
 961         v := int32(value)
 962         return Setsockopt(fd, int32(level), int32(opt), (*byte)(unsafe.Pointer(&v)), int32(unsafe.Sizeof(v)))
 963 }
 964
 965 func Bind(fd Handle, sa Sockaddr) (err error) {
 966         ptr, n, err := sa.sockaddr()
 967         if err != nil {
 968                 return err
 969         }
 970         return bind(fd, ptr, n)
 971 }
 972
 973 func Connect(fd Handle, sa Sockaddr) (err error) {
 974         ptr, n, err := sa.sockaddr()
 975         if err != nil {
 976                 return err
 977         }
 978         return connect(fd, ptr, n)
 979 }
 980
 981 func Getsockname(fd Handle) (sa Sockaddr, err error) {
 982         var rsa RawSockaddrAny
 983         l := int32(unsafe.Sizeof(rsa))
 984         if err = getsockname(fd, &rsa, &l); err != nil {
 985                 return
 986         }
 987         return rsa.Sockaddr()
 988 }
 989
 990 func Getpeername(fd Handle) (sa Sockaddr, err error) {
 991         var rsa RawSockaddrAny
 992         l := int32(unsafe.Sizeof(rsa))
 993         if err = getpeername(fd, &rsa, &l); err != nil {
 994                 return
 995         }
 996         return rsa.Sockaddr()
 997 }
 998
 999 func Listen(s Handle, n int) (err error) {
1000         return listen(s, int32(n))
1001 }
1002
1003 func Shutdown(fd Handle, how int) (err error) {
1004         return shutdown(fd, int32(how))
1005 }
1006
1007 func WSASendto(s Handle, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, to Sockaddr, overlapped *Overlapped, croutine *byte) (err error) {
1008         rsa, l, err := to.sockaddr()
1009         if err != nil {
1010                 return err
1011         }
1012         return WSASendTo(s, bufs, bufcnt, sent, flags, (*RawSockaddrAny)(unsafe.Pointer(rsa)), l, overlapped, croutine)
1013 }
1014
1015 func LoadGetAddrInfo() error {
1016         return procGetAddrInfoW.Find()
1017 }
1018
1019 var connectExFunc struct {
1020         once sync.Once
1021         addr uintptr
1022         err  error
1023 }
1024
1025 func LoadConnectEx() error {
1026         connectExFunc.once.Do(func() {
1027                 var s Handle
1028                 s, connectExFunc.err = Socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)
1029                 if connectExFunc.err != nil {
1030                         return
1031                 }
1032                 defer CloseHandle(s)
1033                 var n uint32
1034                 connectExFunc.err = WSAIoctl(s,
1035                         SIO_GET_EXTENSION_FUNCTION_POINTER,
1036                         (*byte)(unsafe.Pointer(&WSAID_CONNECTEX)),
1037                         uint32(unsafe.Sizeof(WSAID_CONNECTEX)),
1038                         (*byte)(unsafe.Pointer(&connectExFunc.addr)),
1039                         uint32(unsafe.Sizeof(connectExFunc.addr)),
1040                         &n, nil, 0)
1041         })
1042         return connectExFunc.err
1043 }
1044
1045 func connectEx(s Handle, name unsafe.Pointer, namelen int32, sendBuf *byte, sendDataLen uint32, bytesSent *uint32, overlapped *Overlapped) (err error) {
1046         r1, _, e1 := syscall.Syscall9(connectExFunc.addr, 7, uintptr(s), uintptr(name), uintptr(namelen), uintptr(unsafe.Pointer(sendBuf)), uintptr(sendDataLen), uintptr(unsafe.Pointer(bytesSent)), uintptr(unsafe.Pointer(overlapped)), 0, 0)
1047         if r1 == 0 {
1048                 if e1 != 0 {
1049                         err = error(e1)
1050                 } else {
1051                         err = syscall.EINVAL
1052                 }
1053         }
1054         return
1055 }
1056
1057 func ConnectEx(fd Handle, sa Sockaddr, sendBuf *byte, sendDataLen uint32, bytesSent *uint32, overlapped *Overlapped) error {
1058         err := LoadConnectEx()
1059         if err != nil {
1060                 return errorspkg.New("failed to find ConnectEx: " + err.Error())
1061         }
1062         ptr, n, err := sa.sockaddr()
1063         if err != nil {
1064                 return err
1065         }
1066         return connectEx(fd, ptr, n, sendBuf, sendDataLen, bytesSent, overlapped)
1067 }
1068
1069 var sendRecvMsgFunc struct {
1070         once     sync.Once
1071         sendAddr uintptr
1072         recvAddr uintptr
1073         err      error
1074 }
1075
1076 func loadWSASendRecvMsg() error {
1077         sendRecvMsgFunc.once.Do(func() {
1078                 var s Handle
1079                 s, sendRecvMsgFunc.err = Socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)
1080                 if sendRecvMsgFunc.err != nil {
1081                         return
1082                 }
1083                 defer CloseHandle(s)
1084                 var n uint32
1085                 sendRecvMsgFunc.err = WSAIoctl(s,
1086                         SIO_GET_EXTENSION_FUNCTION_POINTER,
1087                         (*byte)(unsafe.Pointer(&WSAID_WSARECVMSG)),
1088                         uint32(unsafe.Sizeof(WSAID_WSARECVMSG)),
1089                         (*byte)(unsafe.Pointer(&sendRecvMsgFunc.recvAddr)),
1090                         uint32(unsafe.Sizeof(sendRecvMsgFunc.recvAddr)),
1091                         &n, nil, 0)
1092                 if sendRecvMsgFunc.err != nil {
1093                         return
1094                 }
1095                 sendRecvMsgFunc.err = WSAIoctl(s,
1096                         SIO_GET_EXTENSION_FUNCTION_POINTER,
1097                         (*byte)(unsafe.Pointer(&WSAID_WSASENDMSG)),
1098                         uint32(unsafe.Sizeof(WSAID_WSASENDMSG)),
1099                         (*byte)(unsafe.Pointer(&sendRecvMsgFunc.sendAddr)),
1100                         uint32(unsafe.Sizeof(sendRecvMsgFunc.sendAddr)),
1101                         &n, nil, 0)
1102         })
1103         return sendRecvMsgFunc.err
1104 }
1105
1106 func WSASendMsg(fd Handle, msg *WSAMsg, flags uint32, bytesSent *uint32, overlapped *Overlapped, croutine *byte) error {
1107         err := loadWSASendRecvMsg()
1108         if err != nil {
1109                 return err
1110         }
1111         r1, _, e1 := syscall.Syscall6(sendRecvMsgFunc.sendAddr, 6, uintptr(fd), uintptr(unsafe.Pointer(msg)), uintptr(flags), uintptr(unsafe.Pointer(bytesSent)), uintptr(unsafe.Pointer(overlapped)), uintptr(unsafe.Pointer(croutine)))
1112         if r1 == socket_error {
1113                 err = errnoErr(e1)
1114         }
1115         return err
1116 }
1117
1118 func WSARecvMsg(fd Handle, msg *WSAMsg, bytesReceived *uint32, overlapped *Overlapped, croutine *byte) error {
1119         err := loadWSASendRecvMsg()
1120         if err != nil {
1121                 return err
1122         }
1123         r1, _, e1 := syscall.Syscall6(sendRecvMsgFunc.recvAddr, 5, uintptr(fd), uintptr(unsafe.Pointer(msg)), uintptr(unsafe.Pointer(bytesReceived)), uintptr(unsafe.Pointer(overlapped)), uintptr(unsafe.Pointer(croutine)), 0)
1124         if r1 == socket_error {
1125                 err = errnoErr(e1)
1126         }
1127         return err
1128 }
1129
1130 // Invented structures to support what package os expects.
1131 type Rusage struct {
1132         CreationTime Filetime
1133         ExitTime     Filetime
1134         KernelTime   Filetime
1135         UserTime     Filetime
1136 }
1137
1138 type WaitStatus struct {
1139         ExitCode uint32
1140 }
1141
1142 func (w WaitStatus) Exited() bool { return true }
1143
1144 func (w WaitStatus) ExitStatus() int { return int(w.ExitCode) }
1145
1146 func (w WaitStatus) Signal() Signal { return -1 }
1147
1148 func (w WaitStatus) CoreDump() bool { return false }
1149
1150 func (w WaitStatus) Stopped() bool { return false }
1151
1152 func (w WaitStatus) Continued() bool { return false }
1153
1154 func (w WaitStatus) StopSignal() Signal { return -1 }
1155
1156 func (w WaitStatus) Signaled() bool { return false }
1157
1158 func (w WaitStatus) TrapCause() int { return -1 }
1159
1160 // Timespec is an invented structure on Windows, but here for
1161 // consistency with the corresponding package for other operating systems.
1162 type Timespec struct {
1163         Sec  int64
1164         Nsec int64
1165 }
1166
1167 func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
1168
1169 func NsecToTimespec(nsec int64) (ts Timespec) {
1170         ts.Sec = nsec / 1e9
1171         ts.Nsec = nsec % 1e9
1172         return
1173 }
1174
1175 // TODO(brainman): fix all needed for net
1176
1177 func Accept(fd Handle) (nfd Handle, sa Sockaddr, err error) { return 0, nil, syscall.EWINDOWS }
1178
1179 func Recvfrom(fd Handle, p []byte, flags int) (n int, from Sockaddr, err error) {
1180         var rsa RawSockaddrAny
1181         l := int32(unsafe.Sizeof(rsa))
1182         n32, err := recvfrom(fd, p, int32(flags), &rsa, &l)
1183         n = int(n32)
1184         if err != nil {
1185                 return
1186         }
1187         from, err = rsa.Sockaddr()
1188         return
1189 }
1190
1191 func Sendto(fd Handle, p []byte, flags int, to Sockaddr) (err error) {
1192         ptr, l, err := to.sockaddr()
1193         if err != nil {
1194                 return err
1195         }
1196         return sendto(fd, p, int32(flags), ptr, l)
1197 }
1198
1199 func SetsockoptTimeval(fd Handle, level, opt int, tv *Timeval) (err error) { return syscall.EWINDOWS }
1200
1201 // The Linger struct is wrong but we only noticed after Go 1.
1202 // sysLinger is the real system call structure.
1203
1204 // BUG(brainman): The definition of Linger is not appropriate for direct use
1205 // with Setsockopt and Getsockopt.
1206 // Use SetsockoptLinger instead.
1207
1208 type Linger struct {
1209         Onoff  int32
1210         Linger int32
1211 }
1212
1213 type sysLinger struct {
1214         Onoff  uint16
1215         Linger uint16
1216 }
1217
1218 type IPMreq struct {
1219         Multiaddr [4]byte /* in_addr */
1220         Interface [4]byte /* in_addr */
1221 }
1222
1223 type IPv6Mreq struct {
1224         Multiaddr [16]byte /* in6_addr */
1225         Interface uint32
1226 }
1227
1228 func GetsockoptInt(fd Handle, level, opt int) (int, error) {
1229         v := int32(0)
1230         l := int32(unsafe.Sizeof(v))
1231         err := Getsockopt(fd, int32(level), int32(opt), (*byte)(unsafe.Pointer(&v)), &l)
1232         return int(v), err
1233 }
1234
1235 func SetsockoptLinger(fd Handle, level, opt int, l *Linger) (err error) {
1236         sys := sysLinger{Onoff: uint16(l.Onoff), Linger: uint16(l.Linger)}
1237         return Setsockopt(fd, int32(level), int32(opt), (*byte)(unsafe.Pointer(&sys)), int32(unsafe.Sizeof(sys)))
1238 }
1239
1240 func SetsockoptInet4Addr(fd Handle, level, opt int, value [4]byte) (err error) {
1241         return Setsockopt(fd, int32(level), int32(opt), (*byte)(unsafe.Pointer(&value[0])), 4)
1242 }
1243 func SetsockoptIPMreq(fd Handle, level, opt int, mreq *IPMreq) (err error) {
1244         return Setsockopt(fd, int32(level), int32(opt), (*byte)(unsafe.Pointer(mreq)), int32(unsafe.Sizeof(*mreq)))
1245 }
1246 func SetsockoptIPv6Mreq(fd Handle, level, opt int, mreq *IPv6Mreq) (err error) {
1247         return syscall.EWINDOWS
1248 }
1249
1250 func Getpid() (pid int) { return int(GetCurrentProcessId()) }
1251
1252 func FindFirstFile(name *uint16, data *Win32finddata) (handle Handle, err error) {
1253         // NOTE(rsc): The Win32finddata struct is wrong for the system call:
1254         // the two paths are each one uint16 short. Use the correct struct,
1255         // a win32finddata1, and then copy the results out.
1256         // There is no loss of expressivity here, because the final
1257         // uint16, if it is used, is supposed to be a NUL, and Go doesn't need that.
1258         // For Go 1.1, we might avoid the allocation of win32finddata1 here
1259         // by adding a final Bug [2]uint16 field to the struct and then
1260         // adjusting the fields in the result directly.
1261         var data1 win32finddata1
1262         handle, err = findFirstFile1(name, &data1)
1263         if err == nil {
1264                 copyFindData(data, &data1)
1265         }
1266         return
1267 }
1268
1269 func FindNextFile(handle Handle, data *Win32finddata) (err error) {
1270         var data1 win32finddata1
1271         err = findNextFile1(handle, &data1)
1272         if err == nil {
1273                 copyFindData(data, &data1)
1274         }
1275         return
1276 }
1277
1278 func getProcessEntry(pid int) (*ProcessEntry32, error) {
1279         snapshot, err := CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0)
1280         if err != nil {
1281                 return nil, err
1282         }
1283         defer CloseHandle(snapshot)
1284         var procEntry ProcessEntry32
1285         procEntry.Size = uint32(unsafe.Sizeof(procEntry))
1286         if err = Process32First(snapshot, &procEntry); err != nil {
1287                 return nil, err
1288         }
1289         for {
1290                 if procEntry.ProcessID == uint32(pid) {
1291                         return &procEntry, nil
1292                 }
1293                 err = Process32Next(snapshot, &procEntry)
1294                 if err != nil {
1295                         return nil, err
1296                 }
1297         }
1298 }
1299
1300 func Getppid() (ppid int) {
1301         pe, err := getProcessEntry(Getpid())
1302         if err != nil {
1303                 return -1
1304         }
1305         return int(pe.ParentProcessID)
1306 }
1307
1308 // TODO(brainman): fix all needed for os
1309 func Fchdir(fd Handle) (err error)             { return syscall.EWINDOWS }
1310 func Link(oldpath, newpath string) (err error) { return syscall.EWINDOWS }
1311 func Symlink(path, link string) (err error)    { return syscall.EWINDOWS }
1312
1313 func Fchmod(fd Handle, mode uint32) (err error)        { return syscall.EWINDOWS }
1314 func Chown(path string, uid int, gid int) (err error)  { return syscall.EWINDOWS }
1315 func Lchown(path string, uid int, gid int) (err error) { return syscall.EWINDOWS }
1316 func Fchown(fd Handle, uid int, gid int) (err error)   { return syscall.EWINDOWS }
1317
1318 func Getuid() (uid int)                  { return -1 }
1319 func Geteuid() (euid int)                { return -1 }
1320 func Getgid() (gid int)                  { return -1 }
1321 func Getegid() (egid int)                { return -1 }
1322 func Getgroups() (gids []int, err error) { return nil, syscall.EWINDOWS }
1323
1324 type Signal int
1325
1326 func (s Signal) Signal() {}
1327
1328 func (s Signal) String() string {
1329         if 0 <= s && int(s) < len(signals) {
1330                 str := signals[s]
1331                 if str != "" {
1332                         return str
1333                 }
1334         }
1335         return "signal " + itoa(int(s))
1336 }
1337
1338 func LoadCreateSymbolicLink() error {
1339         return procCreateSymbolicLinkW.Find()
1340 }
1341
1342 // Readlink returns the destination of the named symbolic link.
1343 func Readlink(path string, buf []byte) (n int, err error) {
1344         fd, err := CreateFile(StringToUTF16Ptr(path), GENERIC_READ, 0, nil, OPEN_EXISTING,
1345                 FILE_FLAG_OPEN_REPARSE_POINT|FILE_FLAG_BACKUP_SEMANTICS, 0)
1346         if err != nil {
1347                 return -1, err
1348         }
1349         defer CloseHandle(fd)
1350
1351         rdbbuf := make([]byte, MAXIMUM_REPARSE_DATA_BUFFER_SIZE)
1352         var bytesReturned uint32
1353         err = DeviceIoControl(fd, FSCTL_GET_REPARSE_POINT, nil, 0, &rdbbuf[0], uint32(len(rdbbuf)), &bytesReturned, nil)
1354         if err != nil {
1355                 return -1, err
1356         }
1357
1358         rdb := (*reparseDataBuffer)(unsafe.Pointer(&rdbbuf[0]))
1359         var s string
1360         switch rdb.ReparseTag {
1361         case IO_REPARSE_TAG_SYMLINK:
1362                 data := (*symbolicLinkReparseBuffer)(unsafe.Pointer(&rdb.reparseBuffer))
1363                 p := (*[0xffff]uint16)(unsafe.Pointer(&data.PathBuffer[0]))
1364                 s = UTF16ToString(p[data.PrintNameOffset/2 : (data.PrintNameLength-data.PrintNameOffset)/2])
1365         case IO_REPARSE_TAG_MOUNT_POINT:
1366                 data := (*mountPointReparseBuffer)(unsafe.Pointer(&rdb.reparseBuffer))
1367                 p := (*[0xffff]uint16)(unsafe.Pointer(&data.PathBuffer[0]))
1368                 s = UTF16ToString(p[data.PrintNameOffset/2 : (data.PrintNameLength-data.PrintNameOffset)/2])
1369         default:
1370                 // the path is not a symlink or junction but another type of reparse
1371                 // point
1372                 return -1, syscall.ENOENT
1373         }
1374         n = copy(buf, []byte(s))
1375
1376         return n, nil
1377 }
1378
1379 // GUIDFromString parses a string in the form of
1380 // "{XXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}" into a GUID.
1381 func GUIDFromString(str string) (GUID, error) {
1382         guid := GUID{}
1383         str16, err := syscall.UTF16PtrFromString(str)
1384         if err != nil {
1385                 return guid, err
1386         }
1387         err = clsidFromString(str16, &guid)
1388         if err != nil {
1389                 return guid, err
1390         }
1391         return guid, nil
1392 }
1393
1394 // GenerateGUID creates a new random GUID.
1395 func GenerateGUID() (GUID, error) {
1396         guid := GUID{}
1397         err := coCreateGuid(&guid)
1398         if err != nil {
1399                 return guid, err
1400         }
1401         return guid, nil
1402 }
1403
1404 // String returns the canonical string form of the GUID,
1405 // in the form of "{XXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}".
1406 func (guid GUID) String() string {
1407         var str [100]uint16
1408         chars := stringFromGUID2(&guid, &str[0], int32(len(str)))
1409         if chars <= 1 {
1410                 return ""
1411         }
1412         return string(utf16.Decode(str[:chars-1]))
1413 }
1414
1415 // KnownFolderPath returns a well-known folder path for the current user, specified by one of
1416 // the FOLDERID_ constants, and chosen and optionally created based on a KF_ flag.
1417 func KnownFolderPath(folderID *KNOWNFOLDERID, flags uint32) (string, error) {
1418         return Token(0).KnownFolderPath(folderID, flags)
1419 }
1420
1421 // KnownFolderPath returns a well-known folder path for the user token, specified by one of
1422 // the FOLDERID_ constants, and chosen and optionally created based on a KF_ flag.
1423 func (t Token) KnownFolderPath(folderID *KNOWNFOLDERID, flags uint32) (string, error) {
1424         var p *uint16
1425         err := shGetKnownFolderPath(folderID, flags, t, &p)
1426         if err != nil {
1427                 return "", err
1428         }
1429         defer CoTaskMemFree(unsafe.Pointer(p))
1430         return UTF16PtrToString(p), nil
1431 }
1432
1433 // RtlGetVersion returns the version of the underlying operating system, ignoring
1434 // manifest semantics but is affected by the application compatibility layer.
1435 func RtlGetVersion() *OsVersionInfoEx {
1436         info := &OsVersionInfoEx{}
1437         info.osVersionInfoSize = uint32(unsafe.Sizeof(*info))
1438         // According to documentation, this function always succeeds.
1439         // The function doesn't even check the validity of the
1440         // osVersionInfoSize member. Disassembling ntdll.dll indicates
1441         // that the documentation is indeed correct about that.
1442         _ = rtlGetVersion(info)
1443         return info
1444 }
1445
1446 // RtlGetNtVersionNumbers returns the version of the underlying operating system,
1447 // ignoring manifest semantics and the application compatibility layer.
1448 func RtlGetNtVersionNumbers() (majorVersion, minorVersion, buildNumber uint32) {
1449         rtlGetNtVersionNumbers(&majorVersion, &minorVersion, &buildNumber)
1450         buildNumber &= 0xffff
1451         return
1452 }
1453
1454 // GetProcessPreferredUILanguages retrieves the process preferred UI languages.
1455 func GetProcessPreferredUILanguages(flags uint32) ([]string, error) {
1456         return getUILanguages(flags, getProcessPreferredUILanguages)
1457 }
1458
1459 // GetThreadPreferredUILanguages retrieves the thread preferred UI languages for the current thread.
1460 func GetThreadPreferredUILanguages(flags uint32) ([]string, error) {
1461         return getUILanguages(flags, getThreadPreferredUILanguages)
1462 }
1463
1464 // GetUserPreferredUILanguages retrieves information about the user preferred UI languages.
1465 func GetUserPreferredUILanguages(flags uint32) ([]string, error) {
1466         return getUILanguages(flags, getUserPreferredUILanguages)
1467 }
1468
1469 // GetSystemPreferredUILanguages retrieves the system preferred UI languages.
1470 func GetSystemPreferredUILanguages(flags uint32) ([]string, error) {
1471         return getUILanguages(flags, getSystemPreferredUILanguages)
1472 }
1473
1474 func getUILanguages(flags uint32, f func(flags uint32, numLanguages *uint32, buf *uint16, bufSize *uint32) error) ([]string, error) {
1475         size := uint32(128)
1476         for {
1477                 var numLanguages uint32
1478                 buf := make([]uint16, size)
1479                 err := f(flags, &numLanguages, &buf[0], &size)
1480                 if err == ERROR_INSUFFICIENT_BUFFER {
1481                         continue
1482                 }
1483                 if err != nil {
1484                         return nil, err
1485                 }
1486                 buf = buf[:size]
1487                 if numLanguages == 0 || len(buf) == 0 { // GetProcessPreferredUILanguages may return numLanguages==0 with "\0\0"
1488                         return []string{}, nil
1489                 }
1490                 if buf[len(buf)-1] == 0 {
1491                         buf = buf[:len(buf)-1] // remove terminating null
1492                 }
1493                 languages := make([]string, 0, numLanguages)
1494                 from := 0
1495                 for i, c := range buf {
1496                         if c == 0 {
1497                                 languages = append(languages, string(utf16.Decode(buf[from:i])))
1498                                 from = i + 1
1499                         }
1500                 }
1501                 return languages, nil
1502         }
1503 }
1504
1505 func SetConsoleCursorPosition(console Handle, position Coord) error {
1506         return setConsoleCursorPosition(console, *((*uint32)(unsafe.Pointer(&position))))
1507 }