vendor/golang.org/x/sys/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         "unicode/utf16"
  14         "unsafe"
  15 )
  16
  17 type Handle uintptr
  18
  19 const InvalidHandle = ^Handle(0)
  20
  21 // StringToUTF16 is deprecated. Use UTF16FromString instead.
  22 // If s contains a NUL byte this function panics instead of
  23 // returning an error.
  24 func StringToUTF16(s string) []uint16 {
  25         a, err := UTF16FromString(s)
  26         if err != nil {
  27                 panic("windows: string with NUL passed to StringToUTF16")
  28         }
  29         return a
  30 }
  31
  32 // UTF16FromString returns the UTF-16 encoding of the UTF-8 string
  33 // s, with a terminating NUL added. If s contains a NUL byte at any
  34 // location, it returns (nil, syscall.EINVAL).
  35 func UTF16FromString(s string) ([]uint16, error) {
  36         for i := 0; i < len(s); i++ {
  37                 if s[i] == 0 {
  38                         return nil, syscall.EINVAL
  39                 }
  40         }
  41         return utf16.Encode([]rune(s + "\x00")), nil
  42 }
  43
  44 // UTF16ToString returns the UTF-8 encoding of the UTF-16 sequence s,
  45 // with a terminating NUL removed.
  46 func UTF16ToString(s []uint16) string {
  47         for i, v := range s {
  48                 if v == 0 {
  49                         s = s[0:i]
  50                         break
  51                 }
  52         }
  53         return string(utf16.Decode(s))
  54 }
  55
  56 // StringToUTF16Ptr is deprecated. Use UTF16PtrFromString instead.
  57 // If s contains a NUL byte this function panics instead of
  58 // returning an error.
  59 func StringToUTF16Ptr(s string) *uint16 { return &StringToUTF16(s)[0] }
  60
  61 // UTF16PtrFromString returns pointer to the UTF-16 encoding of
  62 // the UTF-8 string s, with a terminating NUL added. If s
  63 // contains a NUL byte at any location, it returns (nil, syscall.EINVAL).
  64 func UTF16PtrFromString(s string) (*uint16, error) {
  65         a, err := UTF16FromString(s)
  66         if err != nil {
  67                 return nil, err
  68         }
  69         return &a[0], nil
  70 }
  71
  72 func Getpagesize() int { return 4096 }
  73
  74 // Converts a Go function to a function pointer conforming
  75 // to the stdcall or cdecl calling convention.  This is useful when
  76 // interoperating with Windows code requiring callbacks.
  77 // Implemented in runtime/syscall_windows.goc
  78 func NewCallback(fn interface{}) uintptr
  79 func NewCallbackCDecl(fn interface{}) uintptr
  80
  81 // windows api calls
  82
  83 //sys   GetLastError() (lasterr error)
  84 //sys   LoadLibrary(libname string) (handle Handle, err error) = LoadLibraryW
  85 //sys   LoadLibraryEx(libname string, zero Handle, flags uintptr) (handle Handle, err error) = LoadLibraryExW
  86 //sys   FreeLibrary(handle Handle) (err error)
  87 //sys   GetProcAddress(module Handle, procname string) (proc uintptr, err error)
  88 //sys   GetVersion() (ver uint32, err error)
  89 //sys   FormatMessage(flags uint32, msgsrc uintptr, msgid uint32, langid uint32, buf []uint16, args *byte) (n uint32, err error) = FormatMessageW
  90 //sys   ExitProcess(exitcode uint32)
  91 //sys   CreateFile(name *uint16, access uint32, mode uint32, sa *SecurityAttributes, createmode uint32, attrs uint32, templatefile int32) (handle Handle, err error) [failretval==InvalidHandle] = CreateFileW
  92 //sys   ReadFile(handle Handle, buf []byte, done *uint32, overlapped *Overlapped) (err error)
  93 //sys   WriteFile(handle Handle, buf []byte, done *uint32, overlapped *Overlapped) (err error)
  94 //sys   SetFilePointer(handle Handle, lowoffset int32, highoffsetptr *int32, whence uint32) (newlowoffset uint32, err error) [failretval==0xffffffff]
  95 //sys   CloseHandle(handle Handle) (err error)
  96 //sys   GetStdHandle(stdhandle uint32) (handle Handle, err error) [failretval==InvalidHandle]
  97 //sys   SetStdHandle(stdhandle uint32, handle Handle) (err error)
  98 //sys   findFirstFile1(name *uint16, data *win32finddata1) (handle Handle, err error) [failretval==InvalidHandle] = FindFirstFileW
  99 //sys   findNextFile1(handle Handle, data *win32finddata1) (err error) = FindNextFileW
 100 //sys   FindClose(handle Handle) (err error)
 101 //sys   GetFileInformationByHandle(handle Handle, data *ByHandleFileInformation) (err error)
 102 //sys   GetCurrentDirectory(buflen uint32, buf *uint16) (n uint32, err error) = GetCurrentDirectoryW
 103 //sys   SetCurrentDirectory(path *uint16) (err error) = SetCurrentDirectoryW
 104 //sys   CreateDirectory(path *uint16, sa *SecurityAttributes) (err error) = CreateDirectoryW
 105 //sys   RemoveDirectory(path *uint16) (err error) = RemoveDirectoryW
 106 //sys   DeleteFile(path *uint16) (err error) = DeleteFileW
 107 //sys   MoveFile(from *uint16, to *uint16) (err error) = MoveFileW
 108 //sys   MoveFileEx(from *uint16, to *uint16, flags uint32) (err error) = MoveFileExW
 109 //sys   GetComputerName(buf *uint16, n *uint32) (err error) = GetComputerNameW
 110 //sys   GetComputerNameEx(nametype uint32, buf *uint16, n *uint32) (err error) = GetComputerNameExW
 111 //sys   SetEndOfFile(handle Handle) (err error)
 112 //sys   GetSystemTimeAsFileTime(time *Filetime)
 113 //sys   GetSystemTimePreciseAsFileTime(time *Filetime)
 114 //sys   GetTimeZoneInformation(tzi *Timezoneinformation) (rc uint32, err error) [failretval==0xffffffff]
 115 //sys   CreateIoCompletionPort(filehandle Handle, cphandle Handle, key uint32, threadcnt uint32) (handle Handle, err error)
 116 //sys   GetQueuedCompletionStatus(cphandle Handle, qty *uint32, key *uint32, overlapped **Overlapped, timeout uint32) (err error)
 117 //sys   PostQueuedCompletionStatus(cphandle Handle, qty uint32, key uint32, overlapped *Overlapped) (err error)
 118 //sys   CancelIo(s Handle) (err error)
 119 //sys   CancelIoEx(s Handle, o *Overlapped) (err error)
 120 //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
 121 //sys   OpenProcess(da uint32, inheritHandle bool, pid uint32) (handle Handle, err error)
 122 //sys   TerminateProcess(handle Handle, exitcode uint32) (err error)
 123 //sys   GetExitCodeProcess(handle Handle, exitcode *uint32) (err error)
 124 //sys   GetStartupInfo(startupInfo *StartupInfo) (err error) = GetStartupInfoW
 125 //sys   GetCurrentProcess() (pseudoHandle Handle, err error)
 126 //sys   GetProcessTimes(handle Handle, creationTime *Filetime, exitTime *Filetime, kernelTime *Filetime, userTime *Filetime) (err error)
 127 //sys   DuplicateHandle(hSourceProcessHandle Handle, hSourceHandle Handle, hTargetProcessHandle Handle, lpTargetHandle *Handle, dwDesiredAccess uint32, bInheritHandle bool, dwOptions uint32) (err error)
 128 //sys   WaitForSingleObject(handle Handle, waitMilliseconds uint32) (event uint32, err error) [failretval==0xffffffff]
 129 //sys   GetTempPath(buflen uint32, buf *uint16) (n uint32, err error) = GetTempPathW
 130 //sys   CreatePipe(readhandle *Handle, writehandle *Handle, sa *SecurityAttributes, size uint32) (err error)
 131 //sys   GetFileType(filehandle Handle) (n uint32, err error)
 132 //sys   CryptAcquireContext(provhandle *Handle, container *uint16, provider *uint16, provtype uint32, flags uint32) (err error) = advapi32.CryptAcquireContextW
 133 //sys   CryptReleaseContext(provhandle Handle, flags uint32) (err error) = advapi32.CryptReleaseContext
 134 //sys   CryptGenRandom(provhandle Handle, buflen uint32, buf *byte) (err error) = advapi32.CryptGenRandom
 135 //sys   GetEnvironmentStrings() (envs *uint16, err error) [failretval==nil] = kernel32.GetEnvironmentStringsW
 136 //sys   FreeEnvironmentStrings(envs *uint16) (err error) = kernel32.FreeEnvironmentStringsW
 137 //sys   GetEnvironmentVariable(name *uint16, buffer *uint16, size uint32) (n uint32, err error) = kernel32.GetEnvironmentVariableW
 138 //sys   SetEnvironmentVariable(name *uint16, value *uint16) (err error) = kernel32.SetEnvironmentVariableW
 139 //sys   SetFileTime(handle Handle, ctime *Filetime, atime *Filetime, wtime *Filetime) (err error)
 140 //sys   GetFileAttributes(name *uint16) (attrs uint32, err error) [failretval==INVALID_FILE_ATTRIBUTES] = kernel32.GetFileAttributesW
 141 //sys   SetFileAttributes(name *uint16, attrs uint32) (err error) = kernel32.SetFileAttributesW
 142 //sys   GetFileAttributesEx(name *uint16, level uint32, info *byte) (err error) = kernel32.GetFileAttributesExW
 143 //sys   GetCommandLine() (cmd *uint16) = kernel32.GetCommandLineW
 144 //sys   CommandLineToArgv(cmd *uint16, argc *int32) (argv *[8192]*[8192]uint16, err error) [failretval==nil] = shell32.CommandLineToArgvW
 145 //sys   LocalFree(hmem Handle) (handle Handle, err error) [failretval!=0]
 146 //sys   SetHandleInformation(handle Handle, mask uint32, flags uint32) (err error)
 147 //sys   FlushFileBuffers(handle Handle) (err error)
 148 //sys   GetFullPathName(path *uint16, buflen uint32, buf *uint16, fname **uint16) (n uint32, err error) = kernel32.GetFullPathNameW
 149 //sys   GetLongPathName(path *uint16, buf *uint16, buflen uint32) (n uint32, err error) = kernel32.GetLongPathNameW
 150 //sys   GetShortPathName(longpath *uint16, shortpath *uint16, buflen uint32) (n uint32, err error) = kernel32.GetShortPathNameW
 151 //sys   CreateFileMapping(fhandle Handle, sa *SecurityAttributes, prot uint32, maxSizeHigh uint32, maxSizeLow uint32, name *uint16) (handle Handle, err error) = kernel32.CreateFileMappingW
 152 //sys   MapViewOfFile(handle Handle, access uint32, offsetHigh uint32, offsetLow uint32, length uintptr) (addr uintptr, err error)
 153 //sys   UnmapViewOfFile(addr uintptr) (err error)
 154 //sys   FlushViewOfFile(addr uintptr, length uintptr) (err error)
 155 //sys   VirtualLock(addr uintptr, length uintptr) (err error)
 156 //sys   VirtualUnlock(addr uintptr, length uintptr) (err error)
 157 //sys   TransmitFile(s Handle, handle Handle, bytesToWrite uint32, bytsPerSend uint32, overlapped *Overlapped, transmitFileBuf *TransmitFileBuffers, flags uint32) (err error) = mswsock.TransmitFile
 158 //sys   ReadDirectoryChanges(handle Handle, buf *byte, buflen uint32, watchSubTree bool, mask uint32, retlen *uint32, overlapped *Overlapped, completionRoutine uintptr) (err error) = kernel32.ReadDirectoryChangesW
 159 //sys   CertOpenSystemStore(hprov Handle, name *uint16) (store Handle, err error) = crypt32.CertOpenSystemStoreW
 160 //sys   CertOpenStore(storeProvider uintptr, msgAndCertEncodingType uint32, cryptProv uintptr, flags uint32, para uintptr) (handle Handle, err error) [failretval==InvalidHandle] = crypt32.CertOpenStore
 161 //sys   CertEnumCertificatesInStore(store Handle, prevContext *CertContext) (context *CertContext, err error) [failretval==nil] = crypt32.CertEnumCertificatesInStore
 162 //sys   CertAddCertificateContextToStore(store Handle, certContext *CertContext, addDisposition uint32, storeContext **CertContext) (err error) = crypt32.CertAddCertificateContextToStore
 163 //sys   CertCloseStore(store Handle, flags uint32) (err error) = crypt32.CertCloseStore
 164 //sys   CertGetCertificateChain(engine Handle, leaf *CertContext, time *Filetime, additionalStore Handle, para *CertChainPara, flags uint32, reserved uintptr, chainCtx **CertChainContext) (err error) = crypt32.CertGetCertificateChain
 165 //sys   CertFreeCertificateChain(ctx *CertChainContext) = crypt32.CertFreeCertificateChain
 166 //sys   CertCreateCertificateContext(certEncodingType uint32, certEncoded *byte, encodedLen uint32) (context *CertContext, err error) [failretval==nil] = crypt32.CertCreateCertificateContext
 167 //sys   CertFreeCertificateContext(ctx *CertContext) (err error) = crypt32.CertFreeCertificateContext
 168 //sys   CertVerifyCertificateChainPolicy(policyOID uintptr, chain *CertChainContext, para *CertChainPolicyPara, status *CertChainPolicyStatus) (err error) = crypt32.CertVerifyCertificateChainPolicy
 169 //sys   RegOpenKeyEx(key Handle, subkey *uint16, options uint32, desiredAccess uint32, result *Handle) (regerrno error) = advapi32.RegOpenKeyExW
 170 //sys   RegCloseKey(key Handle) (regerrno error) = advapi32.RegCloseKey
 171 //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
 172 //sys   RegEnumKeyEx(key Handle, index uint32, name *uint16, nameLen *uint32, reserved *uint32, class *uint16, classLen *uint32, lastWriteTime *Filetime) (regerrno error) = advapi32.RegEnumKeyExW
 173 //sys   RegQueryValueEx(key Handle, name *uint16, reserved *uint32, valtype *uint32, buf *byte, buflen *uint32) (regerrno error) = advapi32.RegQueryValueExW
 174 //sys   getCurrentProcessId() (pid uint32) = kernel32.GetCurrentProcessId
 175 //sys   GetConsoleMode(console Handle, mode *uint32) (err error) = kernel32.GetConsoleMode
 176 //sys   WriteConsole(console Handle, buf *uint16, towrite uint32, written *uint32, reserved *byte) (err error) = kernel32.WriteConsoleW
 177 //sys   ReadConsole(console Handle, buf *uint16, toread uint32, read *uint32, inputControl *byte) (err error) = kernel32.ReadConsoleW
 178 //sys   CreateToolhelp32Snapshot(flags uint32, processId uint32) (handle Handle, err error) [failretval==InvalidHandle] = kernel32.CreateToolhelp32Snapshot
 179 //sys   Process32First(snapshot Handle, procEntry *ProcessEntry32) (err error) = kernel32.Process32FirstW
 180 //sys   Process32Next(snapshot Handle, procEntry *ProcessEntry32) (err error) = kernel32.Process32NextW
 181 //sys   DeviceIoControl(handle Handle, ioControlCode uint32, inBuffer *byte, inBufferSize uint32, outBuffer *byte, outBufferSize uint32, bytesReturned *uint32, overlapped *Overlapped) (err error)
 182 // This function returns 1 byte BOOLEAN rather than the 4 byte BOOL.
 183 //sys   CreateSymbolicLink(symlinkfilename *uint16, targetfilename *uint16, flags uint32) (err error) [failretval&0xff==0] = CreateSymbolicLinkW
 184 //sys   CreateHardLink(filename *uint16, existingfilename *uint16, reserved uintptr) (err error) [failretval&0xff==0] = CreateHardLinkW
 185 //sys   GetCurrentThreadId() (id uint32)
 186 //sys   CreateEvent(eventAttrs *syscall.SecurityAttributes, manualReset uint32, initialState uint32, name *uint16) (handle Handle, err error) = kernel32.CreateEventW
 187 //sys   SetEvent(event Handle) (err error) = kernel32.SetEvent
 188
 189 // syscall interface implementation for other packages
 190
 191 func Exit(code int) { ExitProcess(uint32(code)) }
 192
 193 func makeInheritSa() *SecurityAttributes {
 194         var sa SecurityAttributes
 195         sa.Length = uint32(unsafe.Sizeof(sa))
 196         sa.InheritHandle = 1
 197         return &sa
 198 }
 199
 200 func Open(path string, mode int, perm uint32) (fd Handle, err error) {
 201         if len(path) == 0 {
 202                 return InvalidHandle, ERROR_FILE_NOT_FOUND
 203         }
 204         pathp, err := UTF16PtrFromString(path)
 205         if err != nil {
 206                 return InvalidHandle, err
 207         }
 208         var access uint32
 209         switch mode & (O_RDONLY | O_WRONLY | O_RDWR) {
 210         case O_RDONLY:
 211                 access = GENERIC_READ
 212         case O_WRONLY:
 213                 access = GENERIC_WRITE
 214         case O_RDWR:
 215                 access = GENERIC_READ | GENERIC_WRITE
 216         }
 217         if mode&O_CREAT != 0 {
 218                 access |= GENERIC_WRITE
 219         }
 220         if mode&O_APPEND != 0 {
 221                 access &^= GENERIC_WRITE
 222                 access |= FILE_APPEND_DATA
 223         }
 224         sharemode := uint32(FILE_SHARE_READ | FILE_SHARE_WRITE)
 225         var sa *SecurityAttributes
 226         if mode&O_CLOEXEC == 0 {
 227                 sa = makeInheritSa()
 228         }
 229         var createmode uint32
 230         switch {
 231         case mode&(O_CREAT|O_EXCL) == (O_CREAT | O_EXCL):
 232                 createmode = CREATE_NEW
 233         case mode&(O_CREAT|O_TRUNC) == (O_CREAT | O_TRUNC):
 234                 createmode = CREATE_ALWAYS
 235         case mode&O_CREAT == O_CREAT:
 236                 createmode = OPEN_ALWAYS
 237         case mode&O_TRUNC == O_TRUNC:
 238                 createmode = TRUNCATE_EXISTING
 239         default:
 240                 createmode = OPEN_EXISTING
 241         }
 242         h, e := CreateFile(pathp, access, sharemode, sa, createmode, FILE_ATTRIBUTE_NORMAL, 0)
 243         return h, e
 244 }
 245
 246 func Read(fd Handle, p []byte) (n int, err error) {
 247         var done uint32
 248         e := ReadFile(fd, p, &done, nil)
 249         if e != nil {
 250                 if e == ERROR_BROKEN_PIPE {
 251                         // NOTE(brainman): work around ERROR_BROKEN_PIPE is returned on reading EOF from stdin
 252                         return 0, nil
 253                 }
 254                 return 0, e
 255         }
 256         if raceenabled {
 257                 if done > 0 {
 258                         raceWriteRange(unsafe.Pointer(&p[0]), int(done))
 259                 }
 260                 raceAcquire(unsafe.Pointer(&ioSync))
 261         }
 262         return int(done), nil
 263 }
 264
 265 func Write(fd Handle, p []byte) (n int, err error) {
 266         if raceenabled {
 267                 raceReleaseMerge(unsafe.Pointer(&ioSync))
 268         }
 269         var done uint32
 270         e := WriteFile(fd, p, &done, nil)
 271         if e != nil {
 272                 return 0, e
 273         }
 274         if raceenabled && done > 0 {
 275                 raceReadRange(unsafe.Pointer(&p[0]), int(done))
 276         }
 277         return int(done), nil
 278 }
 279
 280 var ioSync int64
 281
 282 func Seek(fd Handle, offset int64, whence int) (newoffset int64, err error) {
 283         var w uint32
 284         switch whence {
 285         case 0:
 286                 w = FILE_BEGIN
 287         case 1:
 288                 w = FILE_CURRENT
 289         case 2:
 290                 w = FILE_END
 291         }
 292         hi := int32(offset >> 32)
 293         lo := int32(offset)
 294         // use GetFileType to check pipe, pipe can't do seek
 295         ft, _ := GetFileType(fd)
 296         if ft == FILE_TYPE_PIPE {
 297                 return 0, syscall.EPIPE
 298         }
 299         rlo, e := SetFilePointer(fd, lo, &hi, w)
 300         if e != nil {
 301                 return 0, e
 302         }
 303         return int64(hi)<<32 + int64(rlo), nil
 304 }
 305
 306 func Close(fd Handle) (err error) {
 307         return CloseHandle(fd)
 308 }
 309
 310 var (
 311         Stdin  = getStdHandle(STD_INPUT_HANDLE)
 312         Stdout = getStdHandle(STD_OUTPUT_HANDLE)
 313         Stderr = getStdHandle(STD_ERROR_HANDLE)
 314 )
 315
 316 func getStdHandle(stdhandle uint32) (fd Handle) {
 317         r, _ := GetStdHandle(stdhandle)
 318         CloseOnExec(r)
 319         return r
 320 }
 321
 322 const ImplementsGetwd = true
 323
 324 func Getwd() (wd string, err error) {
 325         b := make([]uint16, 300)
 326         n, e := GetCurrentDirectory(uint32(len(b)), &b[0])
 327         if e != nil {
 328                 return "", e
 329         }
 330         return string(utf16.Decode(b[0:n])), nil
 331 }
 332
 333 func Chdir(path string) (err error) {
 334         pathp, err := UTF16PtrFromString(path)
 335         if err != nil {
 336                 return err
 337         }
 338         return SetCurrentDirectory(pathp)
 339 }
 340
 341 func Mkdir(path string, mode uint32) (err error) {
 342         pathp, err := UTF16PtrFromString(path)
 343         if err != nil {
 344                 return err
 345         }
 346         return CreateDirectory(pathp, nil)
 347 }
 348
 349 func Rmdir(path string) (err error) {
 350         pathp, err := UTF16PtrFromString(path)
 351         if err != nil {
 352                 return err
 353         }
 354         return RemoveDirectory(pathp)
 355 }
 356
 357 func Unlink(path string) (err error) {
 358         pathp, err := UTF16PtrFromString(path)
 359         if err != nil {
 360                 return err
 361         }
 362         return DeleteFile(pathp)
 363 }
 364
 365 func Rename(oldpath, newpath string) (err error) {
 366         from, err := UTF16PtrFromString(oldpath)
 367         if err != nil {
 368                 return err
 369         }
 370         to, err := UTF16PtrFromString(newpath)
 371         if err != nil {
 372                 return err
 373         }
 374         return MoveFileEx(from, to, MOVEFILE_REPLACE_EXISTING)
 375 }
 376
 377 func ComputerName() (name string, err error) {
 378         var n uint32 = MAX_COMPUTERNAME_LENGTH + 1
 379         b := make([]uint16, n)
 380         e := GetComputerName(&b[0], &n)
 381         if e != nil {
 382                 return "", e
 383         }
 384         return string(utf16.Decode(b[0:n])), nil
 385 }
 386
 387 func Ftruncate(fd Handle, length int64) (err error) {
 388         curoffset, e := Seek(fd, 0, 1)
 389         if e != nil {
 390                 return e
 391         }
 392         defer Seek(fd, curoffset, 0)
 393         _, e = Seek(fd, length, 0)
 394         if e != nil {
 395                 return e
 396         }
 397         e = SetEndOfFile(fd)
 398         if e != nil {
 399                 return e
 400         }
 401         return nil
 402 }
 403
 404 func Gettimeofday(tv *Timeval) (err error) {
 405         var ft Filetime
 406         GetSystemTimeAsFileTime(&ft)
 407         *tv = NsecToTimeval(ft.Nanoseconds())
 408         return nil
 409 }
 410
 411 func Pipe(p []Handle) (err error) {
 412         if len(p) != 2 {
 413                 return syscall.EINVAL
 414         }
 415         var r, w Handle
 416         e := CreatePipe(&r, &w, makeInheritSa(), 0)
 417         if e != nil {
 418                 return e
 419         }
 420         p[0] = r
 421         p[1] = w
 422         return nil
 423 }
 424
 425 func Utimes(path string, tv []Timeval) (err error) {
 426         if len(tv) != 2 {
 427                 return syscall.EINVAL
 428         }
 429         pathp, e := UTF16PtrFromString(path)
 430         if e != nil {
 431                 return e
 432         }
 433         h, e := CreateFile(pathp,
 434                 FILE_WRITE_ATTRIBUTES, FILE_SHARE_WRITE, nil,
 435                 OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0)
 436         if e != nil {
 437                 return e
 438         }
 439         defer Close(h)
 440         a := NsecToFiletime(tv[0].Nanoseconds())
 441         w := NsecToFiletime(tv[1].Nanoseconds())
 442         return SetFileTime(h, nil, &a, &w)
 443 }
 444
 445 func UtimesNano(path string, ts []Timespec) (err error) {
 446         if len(ts) != 2 {
 447                 return syscall.EINVAL
 448         }
 449         pathp, e := UTF16PtrFromString(path)
 450         if e != nil {
 451                 return e
 452         }
 453         h, e := CreateFile(pathp,
 454                 FILE_WRITE_ATTRIBUTES, FILE_SHARE_WRITE, nil,
 455                 OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0)
 456         if e != nil {
 457                 return e
 458         }
 459         defer Close(h)
 460         a := NsecToFiletime(TimespecToNsec(ts[0]))
 461         w := NsecToFiletime(TimespecToNsec(ts[1]))
 462         return SetFileTime(h, nil, &a, &w)
 463 }
 464
 465 func Fsync(fd Handle) (err error) {
 466         return FlushFileBuffers(fd)
 467 }
 468
 469 func Chmod(path string, mode uint32) (err error) {
 470         if mode == 0 {
 471                 return syscall.EINVAL
 472         }
 473         p, e := UTF16PtrFromString(path)
 474         if e != nil {
 475                 return e
 476         }
 477         attrs, e := GetFileAttributes(p)
 478         if e != nil {
 479                 return e
 480         }
 481         if mode&S_IWRITE != 0 {
 482                 attrs &^= FILE_ATTRIBUTE_READONLY
 483         } else {
 484                 attrs |= FILE_ATTRIBUTE_READONLY
 485         }
 486         return SetFileAttributes(p, attrs)
 487 }
 488
 489 func LoadCancelIoEx() error {
 490         return procCancelIoEx.Find()
 491 }
 492
 493 func LoadSetFileCompletionNotificationModes() error {
 494         return procSetFileCompletionNotificationModes.Find()
 495 }
 496
 497 // net api calls
 498
 499 const socket_error = uintptr(^uint32(0))
 500
 501 //sys   WSAStartup(verreq uint32, data *WSAData) (sockerr error) = ws2_32.WSAStartup
 502 //sys   WSACleanup() (err error) [failretval==socket_error] = ws2_32.WSACleanup
 503 //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
 504 //sys   socket(af int32, typ int32, protocol int32) (handle Handle, err error) [failretval==InvalidHandle] = ws2_32.socket
 505 //sys   Setsockopt(s Handle, level int32, optname int32, optval *byte, optlen int32) (err error) [failretval==socket_error] = ws2_32.setsockopt
 506 //sys   Getsockopt(s Handle, level int32, optname int32, optval *byte, optlen *int32) (err error) [failretval==socket_error] = ws2_32.getsockopt
 507 //sys   bind(s Handle, name unsafe.Pointer, namelen int32) (err error) [failretval==socket_error] = ws2_32.bind
 508 //sys   connect(s Handle, name unsafe.Pointer, namelen int32) (err error) [failretval==socket_error] = ws2_32.connect
 509 //sys   getsockname(s Handle, rsa *RawSockaddrAny, addrlen *int32) (err error) [failretval==socket_error] = ws2_32.getsockname
 510 //sys   getpeername(s Handle, rsa *RawSockaddrAny, addrlen *int32) (err error) [failretval==socket_error] = ws2_32.getpeername
 511 //sys   listen(s Handle, backlog int32) (err error) [failretval==socket_error] = ws2_32.listen
 512 //sys   shutdown(s Handle, how int32) (err error) [failretval==socket_error] = ws2_32.shutdown
 513 //sys   Closesocket(s Handle) (err error) [failretval==socket_error] = ws2_32.closesocket
 514 //sys   AcceptEx(ls Handle, as Handle, buf *byte, rxdatalen uint32, laddrlen uint32, raddrlen uint32, recvd *uint32, overlapped *Overlapped) (err error) = mswsock.AcceptEx
 515 //sys   GetAcceptExSockaddrs(buf *byte, rxdatalen uint32, laddrlen uint32, raddrlen uint32, lrsa **RawSockaddrAny, lrsalen *int32, rrsa **RawSockaddrAny, rrsalen *int32) = mswsock.GetAcceptExSockaddrs
 516 //sys   WSARecv(s Handle, bufs *WSABuf, bufcnt uint32, recvd *uint32, flags *uint32, overlapped *Overlapped, croutine *byte) (err error) [failretval==socket_error] = ws2_32.WSARecv
 517 //sys   WSASend(s Handle, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, overlapped *Overlapped, croutine *byte) (err error) [failretval==socket_error] = ws2_32.WSASend
 518 //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
 519 //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
 520 //sys   GetHostByName(name string) (h *Hostent, err error) [failretval==nil] = ws2_32.gethostbyname
 521 //sys   GetServByName(name string, proto string) (s *Servent, err error) [failretval==nil] = ws2_32.getservbyname
 522 //sys   Ntohs(netshort uint16) (u uint16) = ws2_32.ntohs
 523 //sys   GetProtoByName(name string) (p *Protoent, err error) [failretval==nil] = ws2_32.getprotobyname
 524 //sys   DnsQuery(name string, qtype uint16, options uint32, extra *byte, qrs **DNSRecord, pr *byte) (status error) = dnsapi.DnsQuery_W
 525 //sys   DnsRecordListFree(rl *DNSRecord, freetype uint32) = dnsapi.DnsRecordListFree
 526 //sys   DnsNameCompare(name1 *uint16, name2 *uint16) (same bool) = dnsapi.DnsNameCompare_W
 527 //sys   GetAddrInfoW(nodename *uint16, servicename *uint16, hints *AddrinfoW, result **AddrinfoW) (sockerr error) = ws2_32.GetAddrInfoW
 528 //sys   FreeAddrInfoW(addrinfo *AddrinfoW) = ws2_32.FreeAddrInfoW
 529 //sys   GetIfEntry(pIfRow *MibIfRow) (errcode error) = iphlpapi.GetIfEntry
 530 //sys   GetAdaptersInfo(ai *IpAdapterInfo, ol *uint32) (errcode error) = iphlpapi.GetAdaptersInfo
 531 //sys   SetFileCompletionNotificationModes(handle Handle, flags uint8) (err error) = kernel32.SetFileCompletionNotificationModes
 532 //sys   WSAEnumProtocols(protocols *int32, protocolBuffer *WSAProtocolInfo, bufferLength *uint32) (n int32, err error) [failretval==-1] = ws2_32.WSAEnumProtocolsW
 533 //sys   GetAdaptersAddresses(family uint32, flags uint32, reserved uintptr, adapterAddresses *IpAdapterAddresses, sizePointer *uint32) (errcode error) = iphlpapi.GetAdaptersAddresses
 534 //sys   GetACP() (acp uint32) = kernel32.GetACP
 535 //sys   MultiByteToWideChar(codePage uint32, dwFlags uint32, str *byte, nstr int32, wchar *uint16, nwchar int32) (nwrite int32, err error) = kernel32.MultiByteToWideChar
 536
 537 // For testing: clients can set this flag to force
 538 // creation of IPv6 sockets to return EAFNOSUPPORT.
 539 var SocketDisableIPv6 bool
 540
 541 type RawSockaddrInet4 struct {
 542         Family uint16
 543         Port   uint16
 544         Addr   [4]byte /* in_addr */
 545         Zero   [8]uint8
 546 }
 547
 548 type RawSockaddrInet6 struct {
 549         Family   uint16
 550         Port     uint16
 551         Flowinfo uint32
 552         Addr     [16]byte /* in6_addr */
 553         Scope_id uint32
 554 }
 555
 556 type RawSockaddr struct {
 557         Family uint16
 558         Data   [14]int8
 559 }
 560
 561 type RawSockaddrAny struct {
 562         Addr RawSockaddr
 563         Pad  [96]int8
 564 }
 565
 566 type Sockaddr interface {
 567         sockaddr() (ptr unsafe.Pointer, len int32, err error) // lowercase; only we can define Sockaddrs
 568 }
 569
 570 type SockaddrInet4 struct {
 571         Port int
 572         Addr [4]byte
 573         raw  RawSockaddrInet4
 574 }
 575
 576 func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, int32, error) {
 577         if sa.Port < 0 || sa.Port > 0xFFFF {
 578                 return nil, 0, syscall.EINVAL
 579         }
 580         sa.raw.Family = AF_INET
 581         p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
 582         p[0] = byte(sa.Port >> 8)
 583         p[1] = byte(sa.Port)
 584         for i := 0; i < len(sa.Addr); i++ {
 585                 sa.raw.Addr[i] = sa.Addr[i]
 586         }
 587         return unsafe.Pointer(&sa.raw), int32(unsafe.Sizeof(sa.raw)), nil
 588 }
 589
 590 type SockaddrInet6 struct {
 591         Port   int
 592         ZoneId uint32
 593         Addr   [16]byte
 594         raw    RawSockaddrInet6
 595 }
 596
 597 func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, int32, error) {
 598         if sa.Port < 0 || sa.Port > 0xFFFF {
 599                 return nil, 0, syscall.EINVAL
 600         }
 601         sa.raw.Family = AF_INET6
 602         p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
 603         p[0] = byte(sa.Port >> 8)
 604         p[1] = byte(sa.Port)
 605         sa.raw.Scope_id = sa.ZoneId
 606         for i := 0; i < len(sa.Addr); i++ {
 607                 sa.raw.Addr[i] = sa.Addr[i]
 608         }
 609         return unsafe.Pointer(&sa.raw), int32(unsafe.Sizeof(sa.raw)), nil
 610 }
 611
 612 type SockaddrUnix struct {
 613         Name string
 614 }
 615
 616 func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, int32, error) {
 617         // TODO(brainman): implement SockaddrUnix.sockaddr()
 618         return nil, 0, syscall.EWINDOWS
 619 }
 620
 621 func (rsa *RawSockaddrAny) Sockaddr() (Sockaddr, error) {
 622         switch rsa.Addr.Family {
 623         case AF_UNIX:
 624                 return nil, syscall.EWINDOWS
 625
 626         case AF_INET:
 627                 pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa))
 628                 sa := new(SockaddrInet4)
 629                 p := (*[2]byte)(unsafe.Pointer(&pp.Port))
 630                 sa.Port = int(p[0])<<8 + int(p[1])
 631                 for i := 0; i < len(sa.Addr); i++ {
 632                         sa.Addr[i] = pp.Addr[i]
 633                 }
 634                 return sa, nil
 635
 636         case AF_INET6:
 637                 pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa))
 638                 sa := new(SockaddrInet6)
 639                 p := (*[2]byte)(unsafe.Pointer(&pp.Port))
 640                 sa.Port = int(p[0])<<8 + int(p[1])
 641                 sa.ZoneId = pp.Scope_id
 642                 for i := 0; i < len(sa.Addr); i++ {
 643                         sa.Addr[i] = pp.Addr[i]
 644                 }
 645                 return sa, nil
 646         }
 647         return nil, syscall.EAFNOSUPPORT
 648 }
 649
 650 func Socket(domain, typ, proto int) (fd Handle, err error) {
 651         if domain == AF_INET6 && SocketDisableIPv6 {
 652                 return InvalidHandle, syscall.EAFNOSUPPORT
 653         }
 654         return socket(int32(domain), int32(typ), int32(proto))
 655 }
 656
 657 func SetsockoptInt(fd Handle, level, opt int, value int) (err error) {
 658         v := int32(value)
 659         return Setsockopt(fd, int32(level), int32(opt), (*byte)(unsafe.Pointer(&v)), int32(unsafe.Sizeof(v)))
 660 }
 661
 662 func Bind(fd Handle, sa Sockaddr) (err error) {
 663         ptr, n, err := sa.sockaddr()
 664         if err != nil {
 665                 return err
 666         }
 667         return bind(fd, ptr, n)
 668 }
 669
 670 func Connect(fd Handle, sa Sockaddr) (err error) {
 671         ptr, n, err := sa.sockaddr()
 672         if err != nil {
 673                 return err
 674         }
 675         return connect(fd, ptr, n)
 676 }
 677
 678 func Getsockname(fd Handle) (sa Sockaddr, err error) {
 679         var rsa RawSockaddrAny
 680         l := int32(unsafe.Sizeof(rsa))
 681         if err = getsockname(fd, &rsa, &l); err != nil {
 682                 return
 683         }
 684         return rsa.Sockaddr()
 685 }
 686
 687 func Getpeername(fd Handle) (sa Sockaddr, err error) {
 688         var rsa RawSockaddrAny
 689         l := int32(unsafe.Sizeof(rsa))
 690         if err = getpeername(fd, &rsa, &l); err != nil {
 691                 return
 692         }
 693         return rsa.Sockaddr()
 694 }
 695
 696 func Listen(s Handle, n int) (err error) {
 697         return listen(s, int32(n))
 698 }
 699
 700 func Shutdown(fd Handle, how int) (err error) {
 701         return shutdown(fd, int32(how))
 702 }
 703
 704 func WSASendto(s Handle, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, to Sockaddr, overlapped *Overlapped, croutine *byte) (err error) {
 705         rsa, l, err := to.sockaddr()
 706         if err != nil {
 707                 return err
 708         }
 709         return WSASendTo(s, bufs, bufcnt, sent, flags, (*RawSockaddrAny)(unsafe.Pointer(rsa)), l, overlapped, croutine)
 710 }
 711
 712 func LoadGetAddrInfo() error {
 713         return procGetAddrInfoW.Find()
 714 }
 715
 716 var connectExFunc struct {
 717         once sync.Once
 718         addr uintptr
 719         err  error
 720 }
 721
 722 func LoadConnectEx() error {
 723         connectExFunc.once.Do(func() {
 724                 var s Handle
 725                 s, connectExFunc.err = Socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)
 726                 if connectExFunc.err != nil {
 727                         return
 728                 }
 729                 defer CloseHandle(s)
 730                 var n uint32
 731                 connectExFunc.err = WSAIoctl(s,
 732                         SIO_GET_EXTENSION_FUNCTION_POINTER,
 733                         (*byte)(unsafe.Pointer(&WSAID_CONNECTEX)),
 734                         uint32(unsafe.Sizeof(WSAID_CONNECTEX)),
 735                         (*byte)(unsafe.Pointer(&connectExFunc.addr)),
 736                         uint32(unsafe.Sizeof(connectExFunc.addr)),
 737                         &n, nil, 0)
 738         })
 739         return connectExFunc.err
 740 }
 741
 742 func connectEx(s Handle, name unsafe.Pointer, namelen int32, sendBuf *byte, sendDataLen uint32, bytesSent *uint32, overlapped *Overlapped) (err error) {
 743         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)
 744         if r1 == 0 {
 745                 if e1 != 0 {
 746                         err = error(e1)
 747                 } else {
 748                         err = syscall.EINVAL
 749                 }
 750         }
 751         return
 752 }
 753
 754 func ConnectEx(fd Handle, sa Sockaddr, sendBuf *byte, sendDataLen uint32, bytesSent *uint32, overlapped *Overlapped) error {
 755         err := LoadConnectEx()
 756         if err != nil {
 757                 return errorspkg.New("failed to find ConnectEx: " + err.Error())
 758         }
 759         ptr, n, err := sa.sockaddr()
 760         if err != nil {
 761                 return err
 762         }
 763         return connectEx(fd, ptr, n, sendBuf, sendDataLen, bytesSent, overlapped)
 764 }
 765
 766 // Invented structures to support what package os expects.
 767 type Rusage struct {
 768         CreationTime Filetime
 769         ExitTime     Filetime
 770         KernelTime   Filetime
 771         UserTime     Filetime
 772 }
 773
 774 type WaitStatus struct {
 775         ExitCode uint32
 776 }
 777
 778 func (w WaitStatus) Exited() bool { return true }
 779
 780 func (w WaitStatus) ExitStatus() int { return int(w.ExitCode) }
 781
 782 func (w WaitStatus) Signal() Signal { return -1 }
 783
 784 func (w WaitStatus) CoreDump() bool { return false }
 785
 786 func (w WaitStatus) Stopped() bool { return false }
 787
 788 func (w WaitStatus) Continued() bool { return false }
 789
 790 func (w WaitStatus) StopSignal() Signal { return -1 }
 791
 792 func (w WaitStatus) Signaled() bool { return false }
 793
 794 func (w WaitStatus) TrapCause() int { return -1 }
 795
 796 // Timespec is an invented structure on Windows, but here for
 797 // consistency with the corresponding package for other operating systems.
 798 type Timespec struct {
 799         Sec  int64
 800         Nsec int64
 801 }
 802
 803 func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
 804
 805 func NsecToTimespec(nsec int64) (ts Timespec) {
 806         ts.Sec = nsec / 1e9
 807         ts.Nsec = nsec % 1e9
 808         return
 809 }
 810
 811 // TODO(brainman): fix all needed for net
 812
 813 func Accept(fd Handle) (nfd Handle, sa Sockaddr, err error) { return 0, nil, syscall.EWINDOWS }
 814 func Recvfrom(fd Handle, p []byte, flags int) (n int, from Sockaddr, err error) {
 815         return 0, nil, syscall.EWINDOWS
 816 }
 817 func Sendto(fd Handle, p []byte, flags int, to Sockaddr) (err error)       { return syscall.EWINDOWS }
 818 func SetsockoptTimeval(fd Handle, level, opt int, tv *Timeval) (err error) { return syscall.EWINDOWS }
 819
 820 // The Linger struct is wrong but we only noticed after Go 1.
 821 // sysLinger is the real system call structure.
 822
 823 // BUG(brainman): The definition of Linger is not appropriate for direct use
 824 // with Setsockopt and Getsockopt.
 825 // Use SetsockoptLinger instead.
 826
 827 type Linger struct {
 828         Onoff  int32
 829         Linger int32
 830 }
 831
 832 type sysLinger struct {
 833         Onoff  uint16
 834         Linger uint16
 835 }
 836
 837 type IPMreq struct {
 838         Multiaddr [4]byte /* in_addr */
 839         Interface [4]byte /* in_addr */
 840 }
 841
 842 type IPv6Mreq struct {
 843         Multiaddr [16]byte /* in6_addr */
 844         Interface uint32
 845 }
 846
 847 func GetsockoptInt(fd Handle, level, opt int) (int, error) { return -1, syscall.EWINDOWS }
 848
 849 func SetsockoptLinger(fd Handle, level, opt int, l *Linger) (err error) {
 850         sys := sysLinger{Onoff: uint16(l.Onoff), Linger: uint16(l.Linger)}
 851         return Setsockopt(fd, int32(level), int32(opt), (*byte)(unsafe.Pointer(&sys)), int32(unsafe.Sizeof(sys)))
 852 }
 853
 854 func SetsockoptInet4Addr(fd Handle, level, opt int, value [4]byte) (err error) {
 855         return Setsockopt(fd, int32(level), int32(opt), (*byte)(unsafe.Pointer(&value[0])), 4)
 856 }
 857 func SetsockoptIPMreq(fd Handle, level, opt int, mreq *IPMreq) (err error) {
 858         return Setsockopt(fd, int32(level), int32(opt), (*byte)(unsafe.Pointer(mreq)), int32(unsafe.Sizeof(*mreq)))
 859 }
 860 func SetsockoptIPv6Mreq(fd Handle, level, opt int, mreq *IPv6Mreq) (err error) {
 861         return syscall.EWINDOWS
 862 }
 863
 864 func Getpid() (pid int) { return int(getCurrentProcessId()) }
 865
 866 func FindFirstFile(name *uint16, data *Win32finddata) (handle Handle, err error) {
 867         // NOTE(rsc): The Win32finddata struct is wrong for the system call:
 868         // the two paths are each one uint16 short. Use the correct struct,
 869         // a win32finddata1, and then copy the results out.
 870         // There is no loss of expressivity here, because the final
 871         // uint16, if it is used, is supposed to be a NUL, and Go doesn't need that.
 872         // For Go 1.1, we might avoid the allocation of win32finddata1 here
 873         // by adding a final Bug [2]uint16 field to the struct and then
 874         // adjusting the fields in the result directly.
 875         var data1 win32finddata1
 876         handle, err = findFirstFile1(name, &data1)
 877         if err == nil {
 878                 copyFindData(data, &data1)
 879         }
 880         return
 881 }
 882
 883 func FindNextFile(handle Handle, data *Win32finddata) (err error) {
 884         var data1 win32finddata1
 885         err = findNextFile1(handle, &data1)
 886         if err == nil {
 887                 copyFindData(data, &data1)
 888         }
 889         return
 890 }
 891
 892 func getProcessEntry(pid int) (*ProcessEntry32, error) {
 893         snapshot, err := CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0)
 894         if err != nil {
 895                 return nil, err
 896         }
 897         defer CloseHandle(snapshot)
 898         var procEntry ProcessEntry32
 899         procEntry.Size = uint32(unsafe.Sizeof(procEntry))
 900         if err = Process32First(snapshot, &procEntry); err != nil {
 901                 return nil, err
 902         }
 903         for {
 904                 if procEntry.ProcessID == uint32(pid) {
 905                         return &procEntry, nil
 906                 }
 907                 err = Process32Next(snapshot, &procEntry)
 908                 if err != nil {
 909                         return nil, err
 910                 }
 911         }
 912 }
 913
 914 func Getppid() (ppid int) {
 915         pe, err := getProcessEntry(Getpid())
 916         if err != nil {
 917                 return -1
 918         }
 919         return int(pe.ParentProcessID)
 920 }
 921
 922 // TODO(brainman): fix all needed for os
 923 func Fchdir(fd Handle) (err error)             { return syscall.EWINDOWS }
 924 func Link(oldpath, newpath string) (err error) { return syscall.EWINDOWS }
 925 func Symlink(path, link string) (err error)    { return syscall.EWINDOWS }
 926
 927 func Fchmod(fd Handle, mode uint32) (err error)        { return syscall.EWINDOWS }
 928 func Chown(path string, uid int, gid int) (err error)  { return syscall.EWINDOWS }
 929 func Lchown(path string, uid int, gid int) (err error) { return syscall.EWINDOWS }
 930 func Fchown(fd Handle, uid int, gid int) (err error)   { return syscall.EWINDOWS }
 931
 932 func Getuid() (uid int)                  { return -1 }
 933 func Geteuid() (euid int)                { return -1 }
 934 func Getgid() (gid int)                  { return -1 }
 935 func Getegid() (egid int)                { return -1 }
 936 func Getgroups() (gids []int, err error) { return nil, syscall.EWINDOWS }
 937
 938 type Signal int
 939
 940 func (s Signal) Signal() {}
 941
 942 func (s Signal) String() string {
 943         if 0 <= s && int(s) < len(signals) {
 944                 str := signals[s]
 945                 if str != "" {
 946                         return str
 947                 }
 948         }
 949         return "signal " + itoa(int(s))
 950 }
 951
 952 func LoadCreateSymbolicLink() error {
 953         return procCreateSymbolicLinkW.Find()
 954 }
 955
 956 // Readlink returns the destination of the named symbolic link.
 957 func Readlink(path string, buf []byte) (n int, err error) {
 958         fd, err := CreateFile(StringToUTF16Ptr(path), GENERIC_READ, 0, nil, OPEN_EXISTING,
 959                 FILE_FLAG_OPEN_REPARSE_POINT|FILE_FLAG_BACKUP_SEMANTICS, 0)
 960         if err != nil {
 961                 return -1, err
 962         }
 963         defer CloseHandle(fd)
 964
 965         rdbbuf := make([]byte, MAXIMUM_REPARSE_DATA_BUFFER_SIZE)
 966         var bytesReturned uint32
 967         err = DeviceIoControl(fd, FSCTL_GET_REPARSE_POINT, nil, 0, &rdbbuf[0], uint32(len(rdbbuf)), &bytesReturned, nil)
 968         if err != nil {
 969                 return -1, err
 970         }
 971
 972         rdb := (*reparseDataBuffer)(unsafe.Pointer(&rdbbuf[0]))
 973         var s string
 974         switch rdb.ReparseTag {
 975         case IO_REPARSE_TAG_SYMLINK:
 976                 data := (*symbolicLinkReparseBuffer)(unsafe.Pointer(&rdb.reparseBuffer))
 977                 p := (*[0xffff]uint16)(unsafe.Pointer(&data.PathBuffer[0]))
 978                 s = UTF16ToString(p[data.PrintNameOffset/2 : (data.PrintNameLength-data.PrintNameOffset)/2])
 979         case IO_REPARSE_TAG_MOUNT_POINT:
 980                 data := (*mountPointReparseBuffer)(unsafe.Pointer(&rdb.reparseBuffer))
 981                 p := (*[0xffff]uint16)(unsafe.Pointer(&data.PathBuffer[0]))
 982                 s = UTF16ToString(p[data.PrintNameOffset/2 : (data.PrintNameLength-data.PrintNameOffset)/2])
 983         default:
 984                 // the path is not a symlink or junction but another type of reparse
 985                 // point
 986                 return -1, syscall.ENOENT
 987         }
 988         n = copy(buf, []byte(s))
 989
 990         return n, nil
 991 }