2010-03-09 16:09:09 -07:00
|
|
|
// Copyright 2009 The Go Authors. All rights reserved.
|
|
|
|
|
// Use of this source code is governed by a BSD-style
|
|
|
|
|
// license that can be found in the LICENSE file.
|
|
|
|
|
|
|
|
|
|
// Windows system calls.
|
|
|
|
|
|
|
|
|
|
package syscall
|
|
|
|
|
|
2010-03-17 00:10:07 -06:00
|
|
|
import (
|
2013-01-10 18:42:09 -07:00
|
|
|
errorspkg "errors"
|
|
|
|
|
"sync"
|
2011-11-08 16:41:54 -07:00
|
|
|
"unicode/utf16"
|
2010-03-17 00:10:07 -06:00
|
|
|
"unsafe"
|
|
|
|
|
)
|
2010-03-09 16:09:09 -07:00
|
|
|
|
2014-12-21 22:54:07 -07:00
|
|
|
//go:generate go run mksyscall_windows.go -output zsyscall_windows.go syscall_windows.go security_windows.go
|
|
|
|
|
|
2011-07-01 08:18:07 -06:00
|
|
|
type Handle uintptr
|
|
|
|
|
|
|
|
|
|
const InvalidHandle = ^Handle(0)
|
|
|
|
|
|
2015-05-18 13:50:00 -06:00
|
|
|
// StringToUTF16 returns the UTF-16 encoding of the UTF-8 string s,
|
|
|
|
|
// with a terminating NUL added. If s contains a NUL byte this
|
|
|
|
|
// function panics instead of returning an error.
|
|
|
|
|
//
|
|
|
|
|
// Deprecated: Use UTF16FromString instead.
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
func StringToUTF16(s string) []uint16 {
|
|
|
|
|
a, err := UTF16FromString(s)
|
|
|
|
|
if err != nil {
|
|
|
|
|
panic("syscall: string with NUL passed to StringToUTF16")
|
|
|
|
|
}
|
|
|
|
|
return a
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// UTF16FromString returns the UTF-16 encoding of the UTF-8 string
|
|
|
|
|
// s, with a terminating NUL added. If s contains a NUL byte at any
|
|
|
|
|
// location, it returns (nil, EINVAL).
|
|
|
|
|
func UTF16FromString(s string) ([]uint16, error) {
|
|
|
|
|
for i := 0; i < len(s); i++ {
|
|
|
|
|
if s[i] == 0 {
|
|
|
|
|
return nil, EINVAL
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return utf16.Encode([]rune(s + "\x00")), nil
|
|
|
|
|
}
|
2010-03-09 16:09:09 -07:00
|
|
|
|
2010-03-17 00:10:07 -06:00
|
|
|
// UTF16ToString returns the UTF-8 encoding of the UTF-16 sequence s,
|
|
|
|
|
// with a terminating NUL removed.
|
|
|
|
|
func UTF16ToString(s []uint16) string {
|
2010-04-13 17:30:11 -06:00
|
|
|
for i, v := range s {
|
|
|
|
|
if v == 0 {
|
|
|
|
|
s = s[0:i]
|
|
|
|
|
break
|
|
|
|
|
}
|
2010-03-09 16:09:09 -07:00
|
|
|
}
|
2010-03-17 00:10:07 -06:00
|
|
|
return string(utf16.Decode(s))
|
2010-03-09 16:09:09 -07:00
|
|
|
}
|
|
|
|
|
|
2015-05-18 13:50:00 -06:00
|
|
|
// StringToUTF16Ptr returns pointer to the UTF-16 encoding of
|
|
|
|
|
// the UTF-8 string s, with a terminating NUL added. If s
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
// If s contains a NUL byte this function panics instead of
|
|
|
|
|
// returning an error.
|
2015-05-18 13:50:00 -06:00
|
|
|
//
|
|
|
|
|
// Deprecated: Use UTF16PtrFromString instead.
|
2010-03-17 00:10:07 -06:00
|
|
|
func StringToUTF16Ptr(s string) *uint16 { return &StringToUTF16(s)[0] }
|
2010-03-09 16:09:09 -07:00
|
|
|
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
// UTF16PtrFromString returns pointer to the UTF-16 encoding of
|
|
|
|
|
// the UTF-8 string s, with a terminating NUL added. If s
|
|
|
|
|
// contains a NUL byte at any location, it returns (nil, EINVAL).
|
|
|
|
|
func UTF16PtrFromString(s string) (*uint16, error) {
|
|
|
|
|
a, err := UTF16FromString(s)
|
|
|
|
|
if err != nil {
|
|
|
|
|
return nil, err
|
|
|
|
|
}
|
|
|
|
|
return &a[0], nil
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-06 18:40:45 -06:00
|
|
|
func Getpagesize() int { return 4096 }
|
|
|
|
|
|
2011-12-07 18:07:21 -07:00
|
|
|
// Errno is the Windows error number.
|
|
|
|
|
type Errno uintptr
|
|
|
|
|
|
2012-02-19 15:51:25 -07:00
|
|
|
func langid(pri, sub uint16) uint32 { return uint32(sub)<<10 | uint32(pri) }
|
|
|
|
|
|
2011-12-07 18:07:21 -07:00
|
|
|
func (e Errno) Error() string {
|
|
|
|
|
// deal with special go errors
|
|
|
|
|
idx := int(e - APPLICATION_ERROR)
|
|
|
|
|
if 0 <= idx && idx < len(errors) {
|
|
|
|
|
return errors[idx]
|
|
|
|
|
}
|
|
|
|
|
// ask windows for the remaining errors
|
|
|
|
|
var flags uint32 = FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ARGUMENT_ARRAY | FORMAT_MESSAGE_IGNORE_INSERTS
|
|
|
|
|
b := make([]uint16, 300)
|
2012-02-19 15:51:25 -07:00
|
|
|
n, err := FormatMessage(flags, 0, uint32(e), langid(LANG_ENGLISH, SUBLANG_ENGLISH_US), b, nil)
|
2011-12-07 18:07:21 -07:00
|
|
|
if err != nil {
|
2012-09-17 21:02:37 -06:00
|
|
|
n, err = FormatMessage(flags, 0, uint32(e), 0, b, nil)
|
|
|
|
|
if err != nil {
|
|
|
|
|
return "winapi error #" + itoa(int(e))
|
|
|
|
|
}
|
2011-12-07 18:07:21 -07:00
|
|
|
}
|
|
|
|
|
// trim terminating \r and \n
|
|
|
|
|
for ; n > 0 && (b[n-1] == '\n' || b[n-1] == '\r'); n-- {
|
|
|
|
|
}
|
|
|
|
|
return string(utf16.Decode(b[:n]))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (e Errno) Temporary() bool {
|
|
|
|
|
return e == EINTR || e == EMFILE || e.Timeout()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (e Errno) Timeout() bool {
|
|
|
|
|
return e == EAGAIN || e == EWOULDBLOCK || e == ETIMEDOUT
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-14 20:48:45 -06:00
|
|
|
// Implemented in runtime/syscall_windows.go.
|
2014-08-24 23:59:13 -06:00
|
|
|
func compileCallback(fn interface{}, cleanstack bool) uintptr
|
|
|
|
|
|
|
|
|
|
// Converts a Go function to a function pointer conforming
|
|
|
|
|
// to the stdcall calling convention. This is useful when
|
|
|
|
|
// interoperating with Windows code requiring callbacks.
|
|
|
|
|
func NewCallback(fn interface{}) uintptr {
|
|
|
|
|
return compileCallback(fn, true)
|
|
|
|
|
}
|
|
|
|
|
|
2011-02-01 09:49:24 -07:00
|
|
|
// Converts a Go function to a function pointer conforming
|
2014-08-24 23:59:13 -06:00
|
|
|
// to the cdecl calling convention. This is useful when
|
2011-02-01 09:49:24 -07:00
|
|
|
// interoperating with Windows code requiring callbacks.
|
2014-08-24 23:59:13 -06:00
|
|
|
func NewCallbackCDecl(fn interface{}) uintptr {
|
|
|
|
|
return compileCallback(fn, false)
|
|
|
|
|
}
|
2011-01-21 19:55:53 -07:00
|
|
|
|
2010-03-17 00:10:07 -06:00
|
|
|
// windows api calls
|
|
|
|
|
|
2011-12-07 18:07:21 -07:00
|
|
|
//sys GetLastError() (lasterr error)
|
2011-11-13 20:44:52 -07:00
|
|
|
//sys LoadLibrary(libname string) (handle Handle, err error) = LoadLibraryW
|
|
|
|
|
//sys FreeLibrary(handle Handle) (err error)
|
|
|
|
|
//sys GetProcAddress(module Handle, procname string) (proc uintptr, err error)
|
|
|
|
|
//sys GetVersion() (ver uint32, err error)
|
|
|
|
|
//sys FormatMessage(flags uint32, msgsrc uint32, msgid uint32, langid uint32, buf []uint16, args *byte) (n uint32, err error) = FormatMessageW
|
2010-04-02 02:11:17 -06:00
|
|
|
//sys ExitProcess(exitcode uint32)
|
2011-11-13 20:44:52 -07:00
|
|
|
//sys CreateFile(name *uint16, access uint32, mode uint32, sa *SecurityAttributes, createmode uint32, attrs uint32, templatefile int32) (handle Handle, err error) [failretval==InvalidHandle] = CreateFileW
|
|
|
|
|
//sys ReadFile(handle Handle, buf []byte, done *uint32, overlapped *Overlapped) (err error)
|
|
|
|
|
//sys WriteFile(handle Handle, buf []byte, done *uint32, overlapped *Overlapped) (err error)
|
|
|
|
|
//sys SetFilePointer(handle Handle, lowoffset int32, highoffsetptr *int32, whence uint32) (newlowoffset uint32, err error) [failretval==0xffffffff]
|
|
|
|
|
//sys CloseHandle(handle Handle) (err error)
|
|
|
|
|
//sys GetStdHandle(stdhandle int) (handle Handle, err error) [failretval==InvalidHandle]
|
2012-06-08 11:54:48 -06:00
|
|
|
//sys findFirstFile1(name *uint16, data *win32finddata1) (handle Handle, err error) [failretval==InvalidHandle] = FindFirstFileW
|
|
|
|
|
//sys findNextFile1(handle Handle, data *win32finddata1) (err error) = FindNextFileW
|
2011-11-13 20:44:52 -07:00
|
|
|
//sys FindClose(handle Handle) (err error)
|
|
|
|
|
//sys GetFileInformationByHandle(handle Handle, data *ByHandleFileInformation) (err error)
|
|
|
|
|
//sys GetCurrentDirectory(buflen uint32, buf *uint16) (n uint32, err error) = GetCurrentDirectoryW
|
|
|
|
|
//sys SetCurrentDirectory(path *uint16) (err error) = SetCurrentDirectoryW
|
|
|
|
|
//sys CreateDirectory(path *uint16, sa *SecurityAttributes) (err error) = CreateDirectoryW
|
|
|
|
|
//sys RemoveDirectory(path *uint16) (err error) = RemoveDirectoryW
|
|
|
|
|
//sys DeleteFile(path *uint16) (err error) = DeleteFileW
|
|
|
|
|
//sys MoveFile(from *uint16, to *uint16) (err error) = MoveFileW
|
|
|
|
|
//sys GetComputerName(buf *uint16, n *uint32) (err error) = GetComputerNameW
|
|
|
|
|
//sys SetEndOfFile(handle Handle) (err error)
|
2010-04-27 00:17:14 -06:00
|
|
|
//sys GetSystemTimeAsFileTime(time *Filetime)
|
2011-11-13 20:44:52 -07:00
|
|
|
//sys GetTimeZoneInformation(tzi *Timezoneinformation) (rc uint32, err error) [failretval==0xffffffff]
|
|
|
|
|
//sys CreateIoCompletionPort(filehandle Handle, cphandle Handle, key uint32, threadcnt uint32) (handle Handle, err error)
|
|
|
|
|
//sys GetQueuedCompletionStatus(cphandle Handle, qty *uint32, key *uint32, overlapped **Overlapped, timeout uint32) (err error)
|
|
|
|
|
//sys PostQueuedCompletionStatus(cphandle Handle, qty uint32, key uint32, overlapped *Overlapped) (err error)
|
|
|
|
|
//sys CancelIo(s Handle) (err error)
|
net: fix connection resets when closed on windows
It is common to close network connection while another goroutine is
blocked reading on another goroutine. This sequence corresponds to
windows calls to WSARecv to start io, followed by GetQueuedCompletionStatus
that blocks until io completes, and, finally, closesocket called from
another thread. We were expecting that closesocket would unblock
GetQueuedCompletionStatus, and it does, but not always
(http://code.google.com/p/go/issues/detail?id=4170#c5). Also that sequence
results in connection is being reset.
This CL inserts CancelIo between GetQueuedCompletionStatus and closesocket,
and waits for both WSARecv and GetQueuedCompletionStatus to complete before
proceeding to closesocket. This seems to fix both connection resets and
issue 4170. It also makes windows code behave similar to unix version.
Unfortunately, CancelIo needs to be called on the same thread as WSARecv.
So we have to employ strategy we use for connections with deadlines to
every connection now. It means, there are 2 unavoidable thread switches
for every io. Some newer versions of windows have new CancelIoEx api that
doesn't have these drawbacks, and this CL uses this capability when available.
As time goes by, we should have less of CancelIo and more of CancelIoEx
systems. Computers with CancelIoEx are also not affected by issue 4195 anymore.
Fixes #3710
Fixes #3746
Fixes #4170
Partial fix for issue 4195
R=golang-dev, mikioh.mikioh, bradfitz, rsc
CC=golang-dev
https://golang.org/cl/6604072
2012-10-30 17:24:37 -06:00
|
|
|
//sys CancelIoEx(s Handle, o *Overlapped) (err error)
|
2011-11-13 20:44:52 -07:00
|
|
|
//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
|
|
|
|
|
//sys OpenProcess(da uint32, inheritHandle bool, pid uint32) (handle Handle, err error)
|
|
|
|
|
//sys TerminateProcess(handle Handle, exitcode uint32) (err error)
|
|
|
|
|
//sys GetExitCodeProcess(handle Handle, exitcode *uint32) (err error)
|
|
|
|
|
//sys GetStartupInfo(startupInfo *StartupInfo) (err error) = GetStartupInfoW
|
|
|
|
|
//sys GetCurrentProcess() (pseudoHandle Handle, err error)
|
2012-03-01 20:47:40 -07:00
|
|
|
//sys GetProcessTimes(handle Handle, creationTime *Filetime, exitTime *Filetime, kernelTime *Filetime, userTime *Filetime) (err error)
|
2011-11-13 20:44:52 -07:00
|
|
|
//sys DuplicateHandle(hSourceProcessHandle Handle, hSourceHandle Handle, hTargetProcessHandle Handle, lpTargetHandle *Handle, dwDesiredAccess uint32, bInheritHandle bool, dwOptions uint32) (err error)
|
|
|
|
|
//sys WaitForSingleObject(handle Handle, waitMilliseconds uint32) (event uint32, err error) [failretval==0xffffffff]
|
|
|
|
|
//sys GetTempPath(buflen uint32, buf *uint16) (n uint32, err error) = GetTempPathW
|
|
|
|
|
//sys CreatePipe(readhandle *Handle, writehandle *Handle, sa *SecurityAttributes, size uint32) (err error)
|
|
|
|
|
//sys GetFileType(filehandle Handle) (n uint32, err error)
|
|
|
|
|
//sys CryptAcquireContext(provhandle *Handle, container *uint16, provider *uint16, provtype uint32, flags uint32) (err error) = advapi32.CryptAcquireContextW
|
|
|
|
|
//sys CryptReleaseContext(provhandle Handle, flags uint32) (err error) = advapi32.CryptReleaseContext
|
|
|
|
|
//sys CryptGenRandom(provhandle Handle, buflen uint32, buf *byte) (err error) = advapi32.CryptGenRandom
|
|
|
|
|
//sys GetEnvironmentStrings() (envs *uint16, err error) [failretval==nil] = kernel32.GetEnvironmentStringsW
|
|
|
|
|
//sys FreeEnvironmentStrings(envs *uint16) (err error) = kernel32.FreeEnvironmentStringsW
|
|
|
|
|
//sys GetEnvironmentVariable(name *uint16, buffer *uint16, size uint32) (n uint32, err error) = kernel32.GetEnvironmentVariableW
|
|
|
|
|
//sys SetEnvironmentVariable(name *uint16, value *uint16) (err error) = kernel32.SetEnvironmentVariableW
|
|
|
|
|
//sys SetFileTime(handle Handle, ctime *Filetime, atime *Filetime, wtime *Filetime) (err error)
|
|
|
|
|
//sys GetFileAttributes(name *uint16) (attrs uint32, err error) [failretval==INVALID_FILE_ATTRIBUTES] = kernel32.GetFileAttributesW
|
|
|
|
|
//sys SetFileAttributes(name *uint16, attrs uint32) (err error) = kernel32.SetFileAttributesW
|
|
|
|
|
//sys GetFileAttributesEx(name *uint16, level uint32, info *byte) (err error) = kernel32.GetFileAttributesExW
|
2010-12-15 18:18:18 -07:00
|
|
|
//sys GetCommandLine() (cmd *uint16) = kernel32.GetCommandLineW
|
2011-11-13 20:44:52 -07:00
|
|
|
//sys CommandLineToArgv(cmd *uint16, argc *int32) (argv *[8192]*[8192]uint16, err error) [failretval==nil] = shell32.CommandLineToArgvW
|
|
|
|
|
//sys LocalFree(hmem Handle) (handle Handle, err error) [failretval!=0]
|
|
|
|
|
//sys SetHandleInformation(handle Handle, mask uint32, flags uint32) (err error)
|
|
|
|
|
//sys FlushFileBuffers(handle Handle) (err error)
|
|
|
|
|
//sys GetFullPathName(path *uint16, buflen uint32, buf *uint16, fname **uint16) (n uint32, err error) = kernel32.GetFullPathNameW
|
2012-03-07 16:00:25 -07:00
|
|
|
//sys GetLongPathName(path *uint16, buf *uint16, buflen uint32) (n uint32, err error) = kernel32.GetLongPathNameW
|
2012-03-26 22:53:08 -06:00
|
|
|
//sys GetShortPathName(longpath *uint16, shortpath *uint16, buflen uint32) (n uint32, err error) = kernel32.GetShortPathNameW
|
2011-11-13 20:44:52 -07:00
|
|
|
//sys CreateFileMapping(fhandle Handle, sa *SecurityAttributes, prot uint32, maxSizeHigh uint32, maxSizeLow uint32, name *uint16) (handle Handle, err error) = kernel32.CreateFileMappingW
|
|
|
|
|
//sys MapViewOfFile(handle Handle, access uint32, offsetHigh uint32, offsetLow uint32, length uintptr) (addr uintptr, err error)
|
|
|
|
|
//sys UnmapViewOfFile(addr uintptr) (err error)
|
|
|
|
|
//sys FlushViewOfFile(addr uintptr, length uintptr) (err error)
|
|
|
|
|
//sys VirtualLock(addr uintptr, length uintptr) (err error)
|
|
|
|
|
//sys VirtualUnlock(addr uintptr, length uintptr) (err error)
|
|
|
|
|
//sys TransmitFile(s Handle, handle Handle, bytesToWrite uint32, bytsPerSend uint32, overlapped *Overlapped, transmitFileBuf *TransmitFileBuffers, flags uint32) (err error) = mswsock.TransmitFile
|
|
|
|
|
//sys ReadDirectoryChanges(handle Handle, buf *byte, buflen uint32, watchSubTree bool, mask uint32, retlen *uint32, overlapped *Overlapped, completionRoutine uintptr) (err error) = kernel32.ReadDirectoryChangesW
|
|
|
|
|
//sys CertOpenSystemStore(hprov Handle, name *uint16) (store Handle, err error) = crypt32.CertOpenSystemStoreW
|
2012-03-07 11:12:35 -07:00
|
|
|
//sys CertOpenStore(storeProvider uintptr, msgAndCertEncodingType uint32, cryptProv uintptr, flags uint32, para uintptr) (handle Handle, err error) [failretval==InvalidHandle] = crypt32.CertOpenStore
|
2011-12-01 10:38:00 -07:00
|
|
|
//sys CertEnumCertificatesInStore(store Handle, prevContext *CertContext) (context *CertContext, err error) [failretval==nil] = crypt32.CertEnumCertificatesInStore
|
2012-03-07 11:12:35 -07:00
|
|
|
//sys CertAddCertificateContextToStore(store Handle, certContext *CertContext, addDisposition uint32, storeContext **CertContext) (err error) = crypt32.CertAddCertificateContextToStore
|
2011-11-13 20:44:52 -07:00
|
|
|
//sys CertCloseStore(store Handle, flags uint32) (err error) = crypt32.CertCloseStore
|
2012-03-07 11:12:35 -07:00
|
|
|
//sys CertGetCertificateChain(engine Handle, leaf *CertContext, time *Filetime, additionalStore Handle, para *CertChainPara, flags uint32, reserved uintptr, chainCtx **CertChainContext) (err error) = crypt32.CertGetCertificateChain
|
|
|
|
|
//sys CertFreeCertificateChain(ctx *CertChainContext) = crypt32.CertFreeCertificateChain
|
|
|
|
|
//sys CertCreateCertificateContext(certEncodingType uint32, certEncoded *byte, encodedLen uint32) (context *CertContext, err error) [failretval==nil] = crypt32.CertCreateCertificateContext
|
|
|
|
|
//sys CertFreeCertificateContext(ctx *CertContext) (err error) = crypt32.CertFreeCertificateContext
|
|
|
|
|
//sys CertVerifyCertificateChainPolicy(policyOID uintptr, chain *CertChainContext, para *CertChainPolicyPara, status *CertChainPolicyStatus) (err error) = crypt32.CertVerifyCertificateChainPolicy
|
2011-12-07 18:07:21 -07:00
|
|
|
//sys RegOpenKeyEx(key Handle, subkey *uint16, options uint32, desiredAccess uint32, result *Handle) (regerrno error) = advapi32.RegOpenKeyExW
|
|
|
|
|
//sys RegCloseKey(key Handle) (regerrno error) = advapi32.RegCloseKey
|
|
|
|
|
//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
|
|
|
|
|
//sys RegEnumKeyEx(key Handle, index uint32, name *uint16, nameLen *uint32, reserved *uint32, class *uint16, classLen *uint32, lastWriteTime *Filetime) (regerrno error) = advapi32.RegEnumKeyExW
|
|
|
|
|
//sys RegQueryValueEx(key Handle, name *uint16, reserved *uint32, valtype *uint32, buf *byte, buflen *uint32) (regerrno error) = advapi32.RegQueryValueExW
|
2012-06-08 12:28:29 -06:00
|
|
|
//sys getCurrentProcessId() (pid uint32) = kernel32.GetCurrentProcessId
|
2012-09-11 20:04:45 -06:00
|
|
|
//sys GetConsoleMode(console Handle, mode *uint32) (err error) = kernel32.GetConsoleMode
|
|
|
|
|
//sys WriteConsole(console Handle, buf *uint16, towrite uint32, written *uint32, reserved *byte) (err error) = kernel32.WriteConsoleW
|
2013-02-25 20:18:48 -07:00
|
|
|
//sys ReadConsole(console Handle, buf *uint16, toread uint32, read *uint32, inputControl *byte) (err error) = kernel32.ReadConsoleW
|
2014-06-13 23:51:00 -06:00
|
|
|
//sys CreateToolhelp32Snapshot(flags uint32, processId uint32) (handle Handle, err error) [failretval==InvalidHandle] = kernel32.CreateToolhelp32Snapshot
|
|
|
|
|
//sys Process32First(snapshot Handle, procEntry *ProcessEntry32) (err error) = kernel32.Process32FirstW
|
|
|
|
|
//sys Process32Next(snapshot Handle, procEntry *ProcessEntry32) (err error) = kernel32.Process32NextW
|
2014-07-17 01:02:46 -06:00
|
|
|
//sys DeviceIoControl(handle Handle, ioControlCode uint32, inBuffer *byte, inBufferSize uint32, outBuffer *byte, outBufferSize uint32, bytesReturned *uint32, overlapped *Overlapped) (err error)
|
|
|
|
|
// This function returns 1 byte BOOLEAN rather than the 4 byte BOOL.
|
|
|
|
|
//sys CreateSymbolicLink(symlinkfilename *uint16, targetfilename *uint16, flags uint32) (err error) [failretval&0xff==0] = CreateSymbolicLinkW
|
|
|
|
|
//sys CreateHardLink(filename *uint16, existingfilename *uint16, reserved uintptr) (err error) [failretval&0xff==0] = CreateHardLinkW
|
2010-04-02 02:11:17 -06:00
|
|
|
|
|
|
|
|
// syscall interface implementation for other packages
|
2010-03-17 00:10:07 -06:00
|
|
|
|
2010-04-02 02:11:17 -06:00
|
|
|
func Exit(code int) { ExitProcess(uint32(code)) }
|
|
|
|
|
|
2011-02-02 18:50:41 -07:00
|
|
|
func makeInheritSa() *SecurityAttributes {
|
|
|
|
|
var sa SecurityAttributes
|
|
|
|
|
sa.Length = uint32(unsafe.Sizeof(sa))
|
|
|
|
|
sa.InheritHandle = 1
|
|
|
|
|
return &sa
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Open(path string, mode int, perm uint32) (fd Handle, err error) {
|
2010-04-02 02:11:17 -06:00
|
|
|
if len(path) == 0 {
|
2011-07-01 08:18:07 -06:00
|
|
|
return InvalidHandle, ERROR_FILE_NOT_FOUND
|
2010-04-02 02:11:17 -06:00
|
|
|
}
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
pathp, err := UTF16PtrFromString(path)
|
|
|
|
|
if err != nil {
|
|
|
|
|
return InvalidHandle, err
|
|
|
|
|
}
|
2010-04-13 23:30:41 -06:00
|
|
|
var access uint32
|
|
|
|
|
switch mode & (O_RDONLY | O_WRONLY | O_RDWR) {
|
|
|
|
|
case O_RDONLY:
|
2010-04-02 02:11:17 -06:00
|
|
|
access = GENERIC_READ
|
2010-04-13 23:30:41 -06:00
|
|
|
case O_WRONLY:
|
2010-04-02 02:11:17 -06:00
|
|
|
access = GENERIC_WRITE
|
2010-04-13 23:30:41 -06:00
|
|
|
case O_RDWR:
|
2010-04-02 02:11:17 -06:00
|
|
|
access = GENERIC_READ | GENERIC_WRITE
|
|
|
|
|
}
|
2010-04-13 23:30:41 -06:00
|
|
|
if mode&O_CREAT != 0 {
|
|
|
|
|
access |= GENERIC_WRITE
|
|
|
|
|
}
|
2010-09-21 21:12:25 -06:00
|
|
|
if mode&O_APPEND != 0 {
|
|
|
|
|
access &^= GENERIC_WRITE
|
|
|
|
|
access |= FILE_APPEND_DATA
|
|
|
|
|
}
|
2010-04-13 23:30:41 -06:00
|
|
|
sharemode := uint32(FILE_SHARE_READ | FILE_SHARE_WRITE)
|
2011-02-02 18:50:41 -07:00
|
|
|
var sa *SecurityAttributes
|
|
|
|
|
if mode&O_CLOEXEC == 0 {
|
|
|
|
|
sa = makeInheritSa()
|
|
|
|
|
}
|
2010-04-02 02:11:17 -06:00
|
|
|
var createmode uint32
|
|
|
|
|
switch {
|
2011-05-27 01:02:24 -06:00
|
|
|
case mode&(O_CREAT|O_EXCL) == (O_CREAT | O_EXCL):
|
|
|
|
|
createmode = CREATE_NEW
|
|
|
|
|
case mode&(O_CREAT|O_TRUNC) == (O_CREAT | O_TRUNC):
|
|
|
|
|
createmode = CREATE_ALWAYS
|
|
|
|
|
case mode&O_CREAT == O_CREAT:
|
|
|
|
|
createmode = OPEN_ALWAYS
|
|
|
|
|
case mode&O_TRUNC == O_TRUNC:
|
2010-04-02 02:11:17 -06:00
|
|
|
createmode = TRUNCATE_EXISTING
|
|
|
|
|
default:
|
|
|
|
|
createmode = OPEN_EXISTING
|
|
|
|
|
}
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
h, e := CreateFile(pathp, access, sharemode, sa, createmode, FILE_ATTRIBUTE_NORMAL, 0)
|
2011-11-13 20:44:52 -07:00
|
|
|
return h, e
|
2010-04-02 02:11:17 -06:00
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Read(fd Handle, p []byte) (n int, err error) {
|
2010-04-02 02:11:17 -06:00
|
|
|
var done uint32
|
2011-07-01 08:18:07 -06:00
|
|
|
e := ReadFile(fd, p, &done, nil)
|
2011-11-13 20:44:52 -07:00
|
|
|
if e != nil {
|
2010-04-30 13:46:46 -06:00
|
|
|
if e == ERROR_BROKEN_PIPE {
|
2010-08-24 23:26:35 -06:00
|
|
|
// NOTE(brainman): work around ERROR_BROKEN_PIPE is returned on reading EOF from stdin
|
2011-11-13 20:44:52 -07:00
|
|
|
return 0, nil
|
2010-04-30 13:46:46 -06:00
|
|
|
}
|
2010-04-02 02:11:17 -06:00
|
|
|
return 0, e
|
|
|
|
|
}
|
2012-10-09 10:51:58 -06:00
|
|
|
if raceenabled {
|
2013-06-10 12:40:35 -06:00
|
|
|
if done > 0 {
|
|
|
|
|
raceWriteRange(unsafe.Pointer(&p[0]), int(done))
|
|
|
|
|
}
|
2012-10-09 10:51:58 -06:00
|
|
|
raceAcquire(unsafe.Pointer(&ioSync))
|
|
|
|
|
}
|
2011-11-13 20:44:52 -07:00
|
|
|
return int(done), nil
|
2010-04-02 02:11:17 -06:00
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Write(fd Handle, p []byte) (n int, err error) {
|
2012-10-09 10:51:58 -06:00
|
|
|
if raceenabled {
|
|
|
|
|
raceReleaseMerge(unsafe.Pointer(&ioSync))
|
|
|
|
|
}
|
2010-04-02 02:11:17 -06:00
|
|
|
var done uint32
|
2011-07-01 08:18:07 -06:00
|
|
|
e := WriteFile(fd, p, &done, nil)
|
2011-11-13 20:44:52 -07:00
|
|
|
if e != nil {
|
2010-04-02 02:11:17 -06:00
|
|
|
return 0, e
|
|
|
|
|
}
|
2013-06-10 12:40:35 -06:00
|
|
|
if raceenabled && done > 0 {
|
|
|
|
|
raceReadRange(unsafe.Pointer(&p[0]), int(done))
|
|
|
|
|
}
|
2011-11-13 20:44:52 -07:00
|
|
|
return int(done), nil
|
2010-04-02 02:11:17 -06:00
|
|
|
}
|
|
|
|
|
|
2012-10-09 10:51:58 -06:00
|
|
|
var ioSync int64
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Seek(fd Handle, offset int64, whence int) (newoffset int64, err error) {
|
2010-04-02 02:11:17 -06:00
|
|
|
var w uint32
|
|
|
|
|
switch whence {
|
|
|
|
|
case 0:
|
|
|
|
|
w = FILE_BEGIN
|
|
|
|
|
case 1:
|
|
|
|
|
w = FILE_CURRENT
|
|
|
|
|
case 2:
|
|
|
|
|
w = FILE_END
|
|
|
|
|
}
|
|
|
|
|
hi := int32(offset >> 32)
|
|
|
|
|
lo := int32(offset)
|
2010-07-25 23:55:01 -06:00
|
|
|
// use GetFileType to check pipe, pipe can't do seek
|
2011-07-01 08:18:07 -06:00
|
|
|
ft, _ := GetFileType(fd)
|
2010-07-25 23:55:01 -06:00
|
|
|
if ft == FILE_TYPE_PIPE {
|
|
|
|
|
return 0, EPIPE
|
|
|
|
|
}
|
2011-07-01 08:18:07 -06:00
|
|
|
rlo, e := SetFilePointer(fd, lo, &hi, w)
|
2011-11-13 20:44:52 -07:00
|
|
|
if e != nil {
|
2010-04-02 02:11:17 -06:00
|
|
|
return 0, e
|
|
|
|
|
}
|
2011-11-13 20:44:52 -07:00
|
|
|
return int64(hi)<<32 + int64(rlo), nil
|
2010-04-02 02:11:17 -06:00
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Close(fd Handle) (err error) {
|
2011-07-01 08:18:07 -06:00
|
|
|
return CloseHandle(fd)
|
2010-04-02 02:11:17 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var (
|
|
|
|
|
Stdin = getStdHandle(STD_INPUT_HANDLE)
|
|
|
|
|
Stdout = getStdHandle(STD_OUTPUT_HANDLE)
|
|
|
|
|
Stderr = getStdHandle(STD_ERROR_HANDLE)
|
|
|
|
|
)
|
|
|
|
|
|
2011-07-01 08:18:07 -06:00
|
|
|
func getStdHandle(h int) (fd Handle) {
|
2010-04-02 02:11:17 -06:00
|
|
|
r, _ := GetStdHandle(h)
|
2011-09-23 02:16:13 -06:00
|
|
|
CloseOnExec(r)
|
2011-07-01 08:18:07 -06:00
|
|
|
return r
|
2010-04-02 02:11:17 -06:00
|
|
|
}
|
|
|
|
|
|
2010-04-27 00:17:14 -06:00
|
|
|
const ImplementsGetwd = true
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Getwd() (wd string, err error) {
|
2010-04-27 00:17:14 -06:00
|
|
|
b := make([]uint16, 300)
|
|
|
|
|
n, e := GetCurrentDirectory(uint32(len(b)), &b[0])
|
2011-11-13 20:44:52 -07:00
|
|
|
if e != nil {
|
2010-04-27 00:17:14 -06:00
|
|
|
return "", e
|
|
|
|
|
}
|
2011-11-13 20:44:52 -07:00
|
|
|
return string(utf16.Decode(b[0:n])), nil
|
2010-04-27 00:17:14 -06:00
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Chdir(path string) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
pathp, err := UTF16PtrFromString(path)
|
|
|
|
|
if err != nil {
|
|
|
|
|
return err
|
|
|
|
|
}
|
|
|
|
|
return SetCurrentDirectory(pathp)
|
2010-04-27 00:17:14 -06:00
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Mkdir(path string, mode uint32) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
pathp, err := UTF16PtrFromString(path)
|
|
|
|
|
if err != nil {
|
|
|
|
|
return err
|
|
|
|
|
}
|
|
|
|
|
return CreateDirectory(pathp, nil)
|
2010-04-27 00:17:14 -06:00
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Rmdir(path string) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
pathp, err := UTF16PtrFromString(path)
|
|
|
|
|
if err != nil {
|
|
|
|
|
return err
|
|
|
|
|
}
|
|
|
|
|
return RemoveDirectory(pathp)
|
2010-04-27 00:17:14 -06:00
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Unlink(path string) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
pathp, err := UTF16PtrFromString(path)
|
|
|
|
|
if err != nil {
|
|
|
|
|
return err
|
|
|
|
|
}
|
|
|
|
|
return DeleteFile(pathp)
|
2010-04-27 00:17:14 -06:00
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Rename(oldpath, newpath string) (err error) {
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
from, err := UTF16PtrFromString(oldpath)
|
|
|
|
|
if err != nil {
|
|
|
|
|
return err
|
|
|
|
|
}
|
|
|
|
|
to, err := UTF16PtrFromString(newpath)
|
|
|
|
|
if err != nil {
|
|
|
|
|
return err
|
|
|
|
|
}
|
2011-02-10 16:15:51 -07:00
|
|
|
return MoveFile(from, to)
|
2010-04-27 00:17:14 -06:00
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func ComputerName() (name string, err error) {
|
2010-04-27 00:17:14 -06:00
|
|
|
var n uint32 = MAX_COMPUTERNAME_LENGTH + 1
|
|
|
|
|
b := make([]uint16, n)
|
2011-02-10 16:15:51 -07:00
|
|
|
e := GetComputerName(&b[0], &n)
|
2011-11-13 20:44:52 -07:00
|
|
|
if e != nil {
|
2010-04-27 00:17:14 -06:00
|
|
|
return "", e
|
|
|
|
|
}
|
2011-11-13 20:44:52 -07:00
|
|
|
return string(utf16.Decode(b[0:n])), nil
|
2010-04-27 00:17:14 -06:00
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Ftruncate(fd Handle, length int64) (err error) {
|
2010-04-27 00:17:14 -06:00
|
|
|
curoffset, e := Seek(fd, 0, 1)
|
2011-11-13 20:44:52 -07:00
|
|
|
if e != nil {
|
2010-04-27 00:17:14 -06:00
|
|
|
return e
|
|
|
|
|
}
|
|
|
|
|
defer Seek(fd, curoffset, 0)
|
2011-02-10 16:15:51 -07:00
|
|
|
_, e = Seek(fd, length, 0)
|
2011-11-13 20:44:52 -07:00
|
|
|
if e != nil {
|
2010-04-27 00:17:14 -06:00
|
|
|
return e
|
|
|
|
|
}
|
2011-07-01 08:18:07 -06:00
|
|
|
e = SetEndOfFile(fd)
|
2011-11-13 20:44:52 -07:00
|
|
|
if e != nil {
|
2010-04-27 00:17:14 -06:00
|
|
|
return e
|
|
|
|
|
}
|
2011-11-13 20:44:52 -07:00
|
|
|
return nil
|
2010-04-27 00:17:14 -06:00
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Gettimeofday(tv *Timeval) (err error) {
|
2010-04-27 00:17:14 -06:00
|
|
|
var ft Filetime
|
|
|
|
|
GetSystemTimeAsFileTime(&ft)
|
2010-09-22 20:36:52 -06:00
|
|
|
*tv = NsecToTimeval(ft.Nanoseconds())
|
2011-11-13 20:44:52 -07:00
|
|
|
return nil
|
2010-04-27 00:17:14 -06:00
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Pipe(p []Handle) (err error) {
|
2010-07-25 23:55:01 -06:00
|
|
|
if len(p) != 2 {
|
|
|
|
|
return EINVAL
|
|
|
|
|
}
|
2011-07-01 08:18:07 -06:00
|
|
|
var r, w Handle
|
2011-02-10 16:15:51 -07:00
|
|
|
e := CreatePipe(&r, &w, makeInheritSa(), 0)
|
2011-11-13 20:44:52 -07:00
|
|
|
if e != nil {
|
2011-02-10 16:15:51 -07:00
|
|
|
return e
|
2010-07-25 23:55:01 -06:00
|
|
|
}
|
2011-07-01 08:18:07 -06:00
|
|
|
p[0] = r
|
|
|
|
|
p[1] = w
|
2011-11-13 20:44:52 -07:00
|
|
|
return nil
|
2010-07-25 23:55:01 -06:00
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Utimes(path string, tv []Timeval) (err error) {
|
2010-09-22 20:36:52 -06:00
|
|
|
if len(tv) != 2 {
|
|
|
|
|
return EINVAL
|
|
|
|
|
}
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
pathp, e := UTF16PtrFromString(path)
|
|
|
|
|
if e != nil {
|
|
|
|
|
return e
|
|
|
|
|
}
|
|
|
|
|
h, e := CreateFile(pathp,
|
2010-09-22 20:36:52 -06:00
|
|
|
FILE_WRITE_ATTRIBUTES, FILE_SHARE_WRITE, nil,
|
2014-10-06 17:22:48 -06:00
|
|
|
OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0)
|
2011-11-13 20:44:52 -07:00
|
|
|
if e != nil {
|
2010-09-22 20:36:52 -06:00
|
|
|
return e
|
|
|
|
|
}
|
2011-07-01 08:18:07 -06:00
|
|
|
defer Close(h)
|
2010-09-22 20:36:52 -06:00
|
|
|
a := NsecToFiletime(tv[0].Nanoseconds())
|
|
|
|
|
w := NsecToFiletime(tv[1].Nanoseconds())
|
2011-02-10 16:15:51 -07:00
|
|
|
return SetFileTime(h, nil, &a, &w)
|
2010-05-24 12:48:14 -06:00
|
|
|
}
|
|
|
|
|
|
2012-12-13 14:02:39 -07:00
|
|
|
func UtimesNano(path string, ts []Timespec) (err error) {
|
|
|
|
|
if len(ts) != 2 {
|
|
|
|
|
return EINVAL
|
|
|
|
|
}
|
|
|
|
|
pathp, e := UTF16PtrFromString(path)
|
|
|
|
|
if e != nil {
|
|
|
|
|
return e
|
|
|
|
|
}
|
|
|
|
|
h, e := CreateFile(pathp,
|
|
|
|
|
FILE_WRITE_ATTRIBUTES, FILE_SHARE_WRITE, nil,
|
2014-10-06 17:22:48 -06:00
|
|
|
OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0)
|
2012-12-13 14:02:39 -07:00
|
|
|
if e != nil {
|
|
|
|
|
return e
|
|
|
|
|
}
|
|
|
|
|
defer Close(h)
|
|
|
|
|
a := NsecToFiletime(TimespecToNsec(ts[0]))
|
|
|
|
|
w := NsecToFiletime(TimespecToNsec(ts[1]))
|
|
|
|
|
return SetFileTime(h, nil, &a, &w)
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Fsync(fd Handle) (err error) {
|
2011-07-01 08:18:07 -06:00
|
|
|
return FlushFileBuffers(fd)
|
2011-02-08 20:54:54 -07:00
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Chmod(path string, mode uint32) (err error) {
|
2011-02-16 18:09:12 -07:00
|
|
|
if mode == 0 {
|
|
|
|
|
return EINVAL
|
|
|
|
|
}
|
syscall: return EINVAL when string arguments have NUL characters
Since NUL usually terminates strings in underlying syscalls, allowing
it when converting string arguments is a security risk, especially
when dealing with filenames. For example, a program might reason that
filename like "/root/..\x00/" is a subdirectory or "/root/" and allow
access to it, while underlying syscall will treat "\x00" as an end of
that string and the actual filename will be "/root/..", which might
be unexpected. Returning EINVAL when string arguments have NUL in
them makes sure this attack vector is unusable.
R=golang-dev, r, bradfitz, fullung, rsc, minux.ma
CC=golang-dev
https://golang.org/cl/6458050
2012-08-05 15:24:32 -06:00
|
|
|
p, e := UTF16PtrFromString(path)
|
|
|
|
|
if e != nil {
|
|
|
|
|
return e
|
|
|
|
|
}
|
2011-02-16 18:09:12 -07:00
|
|
|
attrs, e := GetFileAttributes(p)
|
2011-11-13 20:44:52 -07:00
|
|
|
if e != nil {
|
2011-02-16 18:09:12 -07:00
|
|
|
return e
|
|
|
|
|
}
|
|
|
|
|
if mode&S_IWRITE != 0 {
|
|
|
|
|
attrs &^= FILE_ATTRIBUTE_READONLY
|
|
|
|
|
} else {
|
|
|
|
|
attrs |= FILE_ATTRIBUTE_READONLY
|
|
|
|
|
}
|
|
|
|
|
return SetFileAttributes(p, attrs)
|
|
|
|
|
}
|
|
|
|
|
|
net: fix connection resets when closed on windows
It is common to close network connection while another goroutine is
blocked reading on another goroutine. This sequence corresponds to
windows calls to WSARecv to start io, followed by GetQueuedCompletionStatus
that blocks until io completes, and, finally, closesocket called from
another thread. We were expecting that closesocket would unblock
GetQueuedCompletionStatus, and it does, but not always
(http://code.google.com/p/go/issues/detail?id=4170#c5). Also that sequence
results in connection is being reset.
This CL inserts CancelIo between GetQueuedCompletionStatus and closesocket,
and waits for both WSARecv and GetQueuedCompletionStatus to complete before
proceeding to closesocket. This seems to fix both connection resets and
issue 4170. It also makes windows code behave similar to unix version.
Unfortunately, CancelIo needs to be called on the same thread as WSARecv.
So we have to employ strategy we use for connections with deadlines to
every connection now. It means, there are 2 unavoidable thread switches
for every io. Some newer versions of windows have new CancelIoEx api that
doesn't have these drawbacks, and this CL uses this capability when available.
As time goes by, we should have less of CancelIo and more of CancelIoEx
systems. Computers with CancelIoEx are also not affected by issue 4195 anymore.
Fixes #3710
Fixes #3746
Fixes #4170
Partial fix for issue 4195
R=golang-dev, mikioh.mikioh, bradfitz, rsc
CC=golang-dev
https://golang.org/cl/6604072
2012-10-30 17:24:37 -06:00
|
|
|
func LoadCancelIoEx() error {
|
|
|
|
|
return procCancelIoEx.Find()
|
|
|
|
|
}
|
|
|
|
|
|
2013-08-08 07:36:43 -06:00
|
|
|
func LoadSetFileCompletionNotificationModes() error {
|
|
|
|
|
return procSetFileCompletionNotificationModes.Find()
|
|
|
|
|
}
|
|
|
|
|
|
2010-06-29 21:23:39 -06:00
|
|
|
// net api calls
|
|
|
|
|
|
2012-09-25 01:06:39 -06:00
|
|
|
const socket_error = uintptr(^uint32(0))
|
|
|
|
|
|
2011-12-07 18:07:21 -07:00
|
|
|
//sys WSAStartup(verreq uint32, data *WSAData) (sockerr error) = ws2_32.WSAStartup
|
2012-09-25 01:06:39 -06:00
|
|
|
//sys WSACleanup() (err error) [failretval==socket_error] = ws2_32.WSACleanup
|
|
|
|
|
//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
|
2011-11-13 20:44:52 -07:00
|
|
|
//sys socket(af int32, typ int32, protocol int32) (handle Handle, err error) [failretval==InvalidHandle] = ws2_32.socket
|
2012-09-25 01:06:39 -06:00
|
|
|
//sys Setsockopt(s Handle, level int32, optname int32, optval *byte, optlen int32) (err error) [failretval==socket_error] = ws2_32.setsockopt
|
|
|
|
|
//sys Getsockopt(s Handle, level int32, optname int32, optval *byte, optlen *int32) (err error) [failretval==socket_error] = ws2_32.getsockopt
|
2014-04-05 20:18:01 -06:00
|
|
|
//sys bind(s Handle, name unsafe.Pointer, namelen int32) (err error) [failretval==socket_error] = ws2_32.bind
|
|
|
|
|
//sys connect(s Handle, name unsafe.Pointer, namelen int32) (err error) [failretval==socket_error] = ws2_32.connect
|
2012-09-25 01:06:39 -06:00
|
|
|
//sys getsockname(s Handle, rsa *RawSockaddrAny, addrlen *int32) (err error) [failretval==socket_error] = ws2_32.getsockname
|
|
|
|
|
//sys getpeername(s Handle, rsa *RawSockaddrAny, addrlen *int32) (err error) [failretval==socket_error] = ws2_32.getpeername
|
|
|
|
|
//sys listen(s Handle, backlog int32) (err error) [failretval==socket_error] = ws2_32.listen
|
|
|
|
|
//sys shutdown(s Handle, how int32) (err error) [failretval==socket_error] = ws2_32.shutdown
|
|
|
|
|
//sys Closesocket(s Handle) (err error) [failretval==socket_error] = ws2_32.closesocket
|
2011-11-13 20:44:52 -07:00
|
|
|
//sys AcceptEx(ls Handle, as Handle, buf *byte, rxdatalen uint32, laddrlen uint32, raddrlen uint32, recvd *uint32, overlapped *Overlapped) (err error) = mswsock.AcceptEx
|
2011-09-08 00:32:40 -06:00
|
|
|
//sys GetAcceptExSockaddrs(buf *byte, rxdatalen uint32, laddrlen uint32, raddrlen uint32, lrsa **RawSockaddrAny, lrsalen *int32, rrsa **RawSockaddrAny, rrsalen *int32) = mswsock.GetAcceptExSockaddrs
|
2012-09-25 01:06:39 -06:00
|
|
|
//sys WSARecv(s Handle, bufs *WSABuf, bufcnt uint32, recvd *uint32, flags *uint32, overlapped *Overlapped, croutine *byte) (err error) [failretval==socket_error] = ws2_32.WSARecv
|
|
|
|
|
//sys WSASend(s Handle, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, overlapped *Overlapped, croutine *byte) (err error) [failretval==socket_error] = ws2_32.WSASend
|
|
|
|
|
//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
|
|
|
|
|
//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
|
2011-11-13 20:44:52 -07:00
|
|
|
//sys GetHostByName(name string) (h *Hostent, err error) [failretval==nil] = ws2_32.gethostbyname
|
|
|
|
|
//sys GetServByName(name string, proto string) (s *Servent, err error) [failretval==nil] = ws2_32.getservbyname
|
2010-07-28 22:58:28 -06:00
|
|
|
//sys Ntohs(netshort uint16) (u uint16) = ws2_32.ntohs
|
2011-11-13 20:44:52 -07:00
|
|
|
//sys GetProtoByName(name string) (p *Protoent, err error) [failretval==nil] = ws2_32.getprotobyname
|
2011-12-07 18:07:21 -07:00
|
|
|
//sys DnsQuery(name string, qtype uint16, options uint32, extra *byte, qrs **DNSRecord, pr *byte) (status error) = dnsapi.DnsQuery_W
|
2010-07-28 22:58:28 -06:00
|
|
|
//sys DnsRecordListFree(rl *DNSRecord, freetype uint32) = dnsapi.DnsRecordListFree
|
2014-08-15 00:37:19 -06:00
|
|
|
//sys DnsNameCompare(name1 *uint16, name2 *uint16) (same bool) = dnsapi.DnsNameCompare_W
|
2012-11-06 22:58:20 -07:00
|
|
|
//sys GetAddrInfoW(nodename *uint16, servicename *uint16, hints *AddrinfoW, result **AddrinfoW) (sockerr error) = ws2_32.GetAddrInfoW
|
|
|
|
|
//sys FreeAddrInfoW(addrinfo *AddrinfoW) = ws2_32.FreeAddrInfoW
|
2011-12-07 18:07:21 -07:00
|
|
|
//sys GetIfEntry(pIfRow *MibIfRow) (errcode error) = iphlpapi.GetIfEntry
|
|
|
|
|
//sys GetAdaptersInfo(ai *IpAdapterInfo, ol *uint32) (errcode error) = iphlpapi.GetAdaptersInfo
|
2013-08-08 07:36:43 -06:00
|
|
|
//sys SetFileCompletionNotificationModes(handle Handle, flags uint8) (err error) = kernel32.SetFileCompletionNotificationModes
|
|
|
|
|
//sys WSAEnumProtocols(protocols *int32, protocolBuffer *WSAProtocolInfo, bufferLength *uint32) (n int32, err error) [failretval==-1] = ws2_32.WSAEnumProtocolsW
|
2010-07-28 22:58:28 -06:00
|
|
|
|
2010-09-11 20:02:29 -06:00
|
|
|
// For testing: clients can set this flag to force
|
|
|
|
|
// creation of IPv6 sockets to return EAFNOSUPPORT.
|
|
|
|
|
var SocketDisableIPv6 bool
|
2010-06-29 21:23:39 -06:00
|
|
|
|
|
|
|
|
type RawSockaddrInet4 struct {
|
|
|
|
|
Family uint16
|
|
|
|
|
Port uint16
|
|
|
|
|
Addr [4]byte /* in_addr */
|
|
|
|
|
Zero [8]uint8
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-06 22:58:20 -07:00
|
|
|
type RawSockaddrInet6 struct {
|
|
|
|
|
Family uint16
|
|
|
|
|
Port uint16
|
|
|
|
|
Flowinfo uint32
|
|
|
|
|
Addr [16]byte /* in6_addr */
|
|
|
|
|
Scope_id uint32
|
|
|
|
|
}
|
|
|
|
|
|
2010-06-29 21:23:39 -06:00
|
|
|
type RawSockaddr struct {
|
|
|
|
|
Family uint16
|
|
|
|
|
Data [14]int8
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
type RawSockaddrAny struct {
|
|
|
|
|
Addr RawSockaddr
|
|
|
|
|
Pad [96]int8
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
type Sockaddr interface {
|
2014-04-05 20:18:01 -06:00
|
|
|
sockaddr() (ptr unsafe.Pointer, len int32, err error) // lowercase; only we can define Sockaddrs
|
2010-06-29 21:23:39 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
type SockaddrInet4 struct {
|
|
|
|
|
Port int
|
|
|
|
|
Addr [4]byte
|
|
|
|
|
raw RawSockaddrInet4
|
|
|
|
|
}
|
|
|
|
|
|
2014-04-05 20:18:01 -06:00
|
|
|
func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, int32, error) {
|
2010-06-29 21:23:39 -06:00
|
|
|
if sa.Port < 0 || sa.Port > 0xFFFF {
|
2014-04-05 20:18:01 -06:00
|
|
|
return nil, 0, EINVAL
|
2010-06-29 21:23:39 -06:00
|
|
|
}
|
|
|
|
|
sa.raw.Family = AF_INET
|
|
|
|
|
p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
|
|
|
|
|
p[0] = byte(sa.Port >> 8)
|
|
|
|
|
p[1] = byte(sa.Port)
|
|
|
|
|
for i := 0; i < len(sa.Addr); i++ {
|
|
|
|
|
sa.raw.Addr[i] = sa.Addr[i]
|
|
|
|
|
}
|
2014-04-05 20:18:01 -06:00
|
|
|
return unsafe.Pointer(&sa.raw), int32(unsafe.Sizeof(sa.raw)), nil
|
2010-06-29 21:23:39 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
type SockaddrInet6 struct {
|
2011-05-22 11:09:07 -06:00
|
|
|
Port int
|
|
|
|
|
ZoneId uint32
|
|
|
|
|
Addr [16]byte
|
2012-11-06 22:58:20 -07:00
|
|
|
raw RawSockaddrInet6
|
2010-06-29 21:23:39 -06:00
|
|
|
}
|
|
|
|
|
|
2014-04-05 20:18:01 -06:00
|
|
|
func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, int32, error) {
|
2012-11-06 22:58:20 -07:00
|
|
|
if sa.Port < 0 || sa.Port > 0xFFFF {
|
2014-04-05 20:18:01 -06:00
|
|
|
return nil, 0, EINVAL
|
2012-11-06 22:58:20 -07:00
|
|
|
}
|
|
|
|
|
sa.raw.Family = AF_INET6
|
|
|
|
|
p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
|
|
|
|
|
p[0] = byte(sa.Port >> 8)
|
|
|
|
|
p[1] = byte(sa.Port)
|
|
|
|
|
sa.raw.Scope_id = sa.ZoneId
|
|
|
|
|
for i := 0; i < len(sa.Addr); i++ {
|
|
|
|
|
sa.raw.Addr[i] = sa.Addr[i]
|
|
|
|
|
}
|
2014-04-05 20:18:01 -06:00
|
|
|
return unsafe.Pointer(&sa.raw), int32(unsafe.Sizeof(sa.raw)), nil
|
2010-06-29 21:23:39 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
type SockaddrUnix struct {
|
|
|
|
|
Name string
|
|
|
|
|
}
|
|
|
|
|
|
2014-04-05 20:18:01 -06:00
|
|
|
func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, int32, error) {
|
2010-06-29 21:23:39 -06:00
|
|
|
// TODO(brainman): implement SockaddrUnix.sockaddr()
|
2014-04-05 20:18:01 -06:00
|
|
|
return nil, 0, EWINDOWS
|
2010-06-29 21:23:39 -06:00
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func (rsa *RawSockaddrAny) Sockaddr() (Sockaddr, error) {
|
2010-06-29 21:23:39 -06:00
|
|
|
switch rsa.Addr.Family {
|
|
|
|
|
case AF_UNIX:
|
|
|
|
|
return nil, EWINDOWS
|
|
|
|
|
|
|
|
|
|
case AF_INET:
|
|
|
|
|
pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa))
|
|
|
|
|
sa := new(SockaddrInet4)
|
|
|
|
|
p := (*[2]byte)(unsafe.Pointer(&pp.Port))
|
|
|
|
|
sa.Port = int(p[0])<<8 + int(p[1])
|
|
|
|
|
for i := 0; i < len(sa.Addr); i++ {
|
|
|
|
|
sa.Addr[i] = pp.Addr[i]
|
|
|
|
|
}
|
2011-11-13 20:44:52 -07:00
|
|
|
return sa, nil
|
2010-06-29 21:23:39 -06:00
|
|
|
|
|
|
|
|
case AF_INET6:
|
2012-11-06 22:58:20 -07:00
|
|
|
pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa))
|
|
|
|
|
sa := new(SockaddrInet6)
|
|
|
|
|
p := (*[2]byte)(unsafe.Pointer(&pp.Port))
|
|
|
|
|
sa.Port = int(p[0])<<8 + int(p[1])
|
|
|
|
|
sa.ZoneId = pp.Scope_id
|
|
|
|
|
for i := 0; i < len(sa.Addr); i++ {
|
|
|
|
|
sa.Addr[i] = pp.Addr[i]
|
|
|
|
|
}
|
|
|
|
|
return sa, nil
|
2010-06-29 21:23:39 -06:00
|
|
|
}
|
|
|
|
|
return nil, EAFNOSUPPORT
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Socket(domain, typ, proto int) (fd Handle, err error) {
|
2010-09-11 20:02:29 -06:00
|
|
|
if domain == AF_INET6 && SocketDisableIPv6 {
|
2011-07-01 08:18:07 -06:00
|
|
|
return InvalidHandle, EAFNOSUPPORT
|
2010-09-11 20:02:29 -06:00
|
|
|
}
|
2011-11-13 20:44:52 -07:00
|
|
|
return socket(int32(domain), int32(typ), int32(proto))
|
2010-06-29 21:23:39 -06:00
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func SetsockoptInt(fd Handle, level, opt int, value int) (err error) {
|
2010-06-29 21:23:39 -06:00
|
|
|
v := int32(value)
|
2011-11-13 20:44:52 -07:00
|
|
|
return Setsockopt(fd, int32(level), int32(opt), (*byte)(unsafe.Pointer(&v)), int32(unsafe.Sizeof(v)))
|
2010-06-29 21:23:39 -06:00
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Bind(fd Handle, sa Sockaddr) (err error) {
|
2010-06-29 21:23:39 -06:00
|
|
|
ptr, n, err := sa.sockaddr()
|
2011-11-13 20:44:52 -07:00
|
|
|
if err != nil {
|
2010-06-29 21:23:39 -06:00
|
|
|
return err
|
|
|
|
|
}
|
2011-07-01 08:18:07 -06:00
|
|
|
return bind(fd, ptr, n)
|
2010-06-29 21:23:39 -06:00
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Connect(fd Handle, sa Sockaddr) (err error) {
|
2010-06-29 21:23:39 -06:00
|
|
|
ptr, n, err := sa.sockaddr()
|
2011-11-13 20:44:52 -07:00
|
|
|
if err != nil {
|
2010-06-29 21:23:39 -06:00
|
|
|
return err
|
|
|
|
|
}
|
2011-07-01 08:18:07 -06:00
|
|
|
return connect(fd, ptr, n)
|
2010-06-29 21:23:39 -06:00
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Getsockname(fd Handle) (sa Sockaddr, err error) {
|
2010-06-29 21:23:39 -06:00
|
|
|
var rsa RawSockaddrAny
|
|
|
|
|
l := int32(unsafe.Sizeof(rsa))
|
2011-11-13 20:44:52 -07:00
|
|
|
if err = getsockname(fd, &rsa, &l); err != nil {
|
2010-06-29 21:23:39 -06:00
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
return rsa.Sockaddr()
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Getpeername(fd Handle) (sa Sockaddr, err error) {
|
2010-06-29 21:23:39 -06:00
|
|
|
var rsa RawSockaddrAny
|
|
|
|
|
l := int32(unsafe.Sizeof(rsa))
|
2011-11-13 20:44:52 -07:00
|
|
|
if err = getpeername(fd, &rsa, &l); err != nil {
|
2010-06-29 21:23:39 -06:00
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
return rsa.Sockaddr()
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Listen(s Handle, n int) (err error) {
|
|
|
|
|
return listen(s, int32(n))
|
2010-06-29 21:23:39 -06:00
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Shutdown(fd Handle, how int) (err error) {
|
|
|
|
|
return shutdown(fd, int32(how))
|
2010-06-29 21:23:39 -06:00
|
|
|
}
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func WSASendto(s Handle, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, to Sockaddr, overlapped *Overlapped, croutine *byte) (err error) {
|
2010-11-22 09:01:30 -07:00
|
|
|
rsa, l, err := to.sockaddr()
|
2011-11-13 20:44:52 -07:00
|
|
|
if err != nil {
|
2010-11-22 09:01:30 -07:00
|
|
|
return err
|
|
|
|
|
}
|
2011-11-13 20:44:52 -07:00
|
|
|
return WSASendTo(s, bufs, bufcnt, sent, flags, (*RawSockaddrAny)(unsafe.Pointer(rsa)), l, overlapped, croutine)
|
2010-11-22 09:01:30 -07:00
|
|
|
}
|
|
|
|
|
|
2012-11-06 22:58:20 -07:00
|
|
|
func LoadGetAddrInfo() error {
|
|
|
|
|
return procGetAddrInfoW.Find()
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-10 18:42:09 -07:00
|
|
|
var connectExFunc struct {
|
|
|
|
|
once sync.Once
|
|
|
|
|
addr uintptr
|
|
|
|
|
err error
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func LoadConnectEx() error {
|
|
|
|
|
connectExFunc.once.Do(func() {
|
|
|
|
|
var s Handle
|
|
|
|
|
s, connectExFunc.err = Socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)
|
|
|
|
|
if connectExFunc.err != nil {
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
defer CloseHandle(s)
|
|
|
|
|
var n uint32
|
|
|
|
|
connectExFunc.err = WSAIoctl(s,
|
|
|
|
|
SIO_GET_EXTENSION_FUNCTION_POINTER,
|
|
|
|
|
(*byte)(unsafe.Pointer(&WSAID_CONNECTEX)),
|
|
|
|
|
uint32(unsafe.Sizeof(WSAID_CONNECTEX)),
|
|
|
|
|
(*byte)(unsafe.Pointer(&connectExFunc.addr)),
|
|
|
|
|
uint32(unsafe.Sizeof(connectExFunc.addr)),
|
|
|
|
|
&n, nil, 0)
|
|
|
|
|
})
|
|
|
|
|
return connectExFunc.err
|
|
|
|
|
}
|
|
|
|
|
|
2014-04-05 20:18:01 -06:00
|
|
|
func connectEx(s Handle, name unsafe.Pointer, namelen int32, sendBuf *byte, sendDataLen uint32, bytesSent *uint32, overlapped *Overlapped) (err error) {
|
2013-01-10 18:42:09 -07:00
|
|
|
r1, _, e1 := 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)
|
|
|
|
|
if r1 == 0 {
|
|
|
|
|
if e1 != 0 {
|
|
|
|
|
err = error(e1)
|
|
|
|
|
} else {
|
|
|
|
|
err = EINVAL
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func ConnectEx(fd Handle, sa Sockaddr, sendBuf *byte, sendDataLen uint32, bytesSent *uint32, overlapped *Overlapped) error {
|
|
|
|
|
err := LoadConnectEx()
|
|
|
|
|
if err != nil {
|
|
|
|
|
return errorspkg.New("failed to find ConnectEx: " + err.Error())
|
|
|
|
|
}
|
|
|
|
|
ptr, n, err := sa.sockaddr()
|
|
|
|
|
if err != nil {
|
|
|
|
|
return err
|
|
|
|
|
}
|
|
|
|
|
return connectEx(fd, ptr, n, sendBuf, sendDataLen, bytesSent, overlapped)
|
|
|
|
|
}
|
|
|
|
|
|
2011-02-03 20:41:26 -07:00
|
|
|
// Invented structures to support what package os expects.
|
2012-03-01 20:47:40 -07:00
|
|
|
type Rusage struct {
|
|
|
|
|
CreationTime Filetime
|
|
|
|
|
ExitTime Filetime
|
|
|
|
|
KernelTime Filetime
|
|
|
|
|
UserTime Filetime
|
|
|
|
|
}
|
2011-02-03 20:41:26 -07:00
|
|
|
|
|
|
|
|
type WaitStatus struct {
|
|
|
|
|
ExitCode uint32
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func (w WaitStatus) Exited() bool { return true }
|
|
|
|
|
|
|
|
|
|
func (w WaitStatus) ExitStatus() int { return int(w.ExitCode) }
|
|
|
|
|
|
2012-02-13 19:51:38 -07:00
|
|
|
func (w WaitStatus) Signal() Signal { return -1 }
|
2011-02-03 20:41:26 -07:00
|
|
|
|
|
|
|
|
func (w WaitStatus) CoreDump() bool { return false }
|
|
|
|
|
|
|
|
|
|
func (w WaitStatus) Stopped() bool { return false }
|
|
|
|
|
|
|
|
|
|
func (w WaitStatus) Continued() bool { return false }
|
|
|
|
|
|
2012-02-13 19:51:38 -07:00
|
|
|
func (w WaitStatus) StopSignal() Signal { return -1 }
|
2011-02-03 20:41:26 -07:00
|
|
|
|
2011-04-07 18:27:47 -06:00
|
|
|
func (w WaitStatus) Signaled() bool { return false }
|
2011-02-03 20:41:26 -07:00
|
|
|
|
|
|
|
|
func (w WaitStatus) TrapCause() int { return -1 }
|
|
|
|
|
|
2012-01-18 20:05:44 -07:00
|
|
|
// Timespec is an invented structure on Windows, but here for
|
|
|
|
|
// consistency with the syscall package for other operating systems.
|
|
|
|
|
type Timespec struct {
|
|
|
|
|
Sec int64
|
|
|
|
|
Nsec int64
|
|
|
|
|
}
|
|
|
|
|
|
2012-12-13 14:02:39 -07:00
|
|
|
func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
|
|
|
|
|
|
|
|
|
|
func NsecToTimespec(nsec int64) (ts Timespec) {
|
|
|
|
|
ts.Sec = nsec / 1e9
|
|
|
|
|
ts.Nsec = nsec % 1e9
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2010-06-29 21:23:39 -06:00
|
|
|
// TODO(brainman): fix all needed for net
|
|
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Accept(fd Handle) (nfd Handle, sa Sockaddr, err error) { return 0, nil, EWINDOWS }
|
|
|
|
|
func Recvfrom(fd Handle, p []byte, flags int) (n int, from Sockaddr, err error) {
|
2011-07-01 08:18:07 -06:00
|
|
|
return 0, nil, EWINDOWS
|
|
|
|
|
}
|
2011-11-13 20:44:52 -07:00
|
|
|
func Sendto(fd Handle, p []byte, flags int, to Sockaddr) (err error) { return EWINDOWS }
|
|
|
|
|
func SetsockoptTimeval(fd Handle, level, opt int, tv *Timeval) (err error) { return EWINDOWS }
|
2010-06-29 21:23:39 -06:00
|
|
|
|
2012-05-22 21:05:05 -06:00
|
|
|
// The Linger struct is wrong but we only noticed after Go 1.
|
|
|
|
|
// sysLinger is the real system call structure.
|
|
|
|
|
|
|
|
|
|
// BUG(brainman): The definition of Linger is not appropriate for direct use
|
|
|
|
|
// with Setsockopt and Getsockopt.
|
|
|
|
|
// Use SetsockoptLinger instead.
|
|
|
|
|
|
2010-06-29 21:23:39 -06:00
|
|
|
type Linger struct {
|
|
|
|
|
Onoff int32
|
|
|
|
|
Linger int32
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-22 21:05:05 -06:00
|
|
|
type sysLinger struct {
|
|
|
|
|
Onoff uint16
|
|
|
|
|
Linger uint16
|
|
|
|
|
}
|
|
|
|
|
|
2011-06-02 08:10:17 -06:00
|
|
|
type IPMreq struct {
|
2011-02-16 18:00:02 -07:00
|
|
|
Multiaddr [4]byte /* in_addr */
|
|
|
|
|
Interface [4]byte /* in_addr */
|
|
|
|
|
}
|
|
|
|
|
|
2011-06-02 08:10:17 -06:00
|
|
|
type IPv6Mreq struct {
|
|
|
|
|
Multiaddr [16]byte /* in6_addr */
|
|
|
|
|
Interface uint32
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-22 21:05:05 -06:00
|
|
|
func GetsockoptInt(fd Handle, level, opt int) (int, error) { return -1, EWINDOWS }
|
|
|
|
|
|
|
|
|
|
func SetsockoptLinger(fd Handle, level, opt int, l *Linger) (err error) {
|
|
|
|
|
sys := sysLinger{Onoff: uint16(l.Onoff), Linger: uint16(l.Linger)}
|
|
|
|
|
return Setsockopt(fd, int32(level), int32(opt), (*byte)(unsafe.Pointer(&sys)), int32(unsafe.Sizeof(sys)))
|
|
|
|
|
}
|
|
|
|
|
|
2012-01-31 22:14:04 -07:00
|
|
|
func SetsockoptInet4Addr(fd Handle, level, opt int, value [4]byte) (err error) {
|
|
|
|
|
return Setsockopt(fd, int32(level), int32(opt), (*byte)(unsafe.Pointer(&value[0])), 4)
|
|
|
|
|
}
|
2011-11-13 20:44:52 -07:00
|
|
|
func SetsockoptIPMreq(fd Handle, level, opt int, mreq *IPMreq) (err error) {
|
2011-09-08 00:32:40 -06:00
|
|
|
return Setsockopt(fd, int32(level), int32(opt), (*byte)(unsafe.Pointer(mreq)), int32(unsafe.Sizeof(*mreq)))
|
|
|
|
|
}
|
2011-11-13 20:44:52 -07:00
|
|
|
func SetsockoptIPv6Mreq(fd Handle, level, opt int, mreq *IPv6Mreq) (err error) { return EWINDOWS }
|
2010-06-29 21:23:39 -06:00
|
|
|
|
2012-06-08 12:28:29 -06:00
|
|
|
func Getpid() (pid int) { return int(getCurrentProcessId()) }
|
2010-04-02 02:11:17 -06:00
|
|
|
|
2012-06-03 03:27:17 -06:00
|
|
|
func FindFirstFile(name *uint16, data *Win32finddata) (handle Handle, err error) {
|
2012-06-08 11:54:48 -06:00
|
|
|
// NOTE(rsc): The Win32finddata struct is wrong for the system call:
|
|
|
|
|
// the two paths are each one uint16 short. Use the correct struct,
|
|
|
|
|
// a win32finddata1, and then copy the results out.
|
|
|
|
|
// There is no loss of expressivity here, because the final
|
|
|
|
|
// uint16, if it is used, is supposed to be a NUL, and Go doesn't need that.
|
|
|
|
|
// For Go 1.1, we might avoid the allocation of win32finddata1 here
|
|
|
|
|
// by adding a final Bug [2]uint16 field to the struct and then
|
|
|
|
|
// adjusting the fields in the result directly.
|
|
|
|
|
var data1 win32finddata1
|
|
|
|
|
handle, err = findFirstFile1(name, &data1)
|
|
|
|
|
if err == nil {
|
|
|
|
|
copyFindData(data, &data1)
|
|
|
|
|
}
|
|
|
|
|
return
|
2012-06-03 03:27:17 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func FindNextFile(handle Handle, data *Win32finddata) (err error) {
|
2012-06-08 11:54:48 -06:00
|
|
|
var data1 win32finddata1
|
|
|
|
|
err = findNextFile1(handle, &data1)
|
|
|
|
|
if err == nil {
|
|
|
|
|
copyFindData(data, &data1)
|
|
|
|
|
}
|
|
|
|
|
return
|
2012-06-03 03:27:17 -06:00
|
|
|
}
|
|
|
|
|
|
2014-06-13 23:51:00 -06:00
|
|
|
func getProcessEntry(pid int) (*ProcessEntry32, error) {
|
|
|
|
|
snapshot, err := CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0)
|
|
|
|
|
if err != nil {
|
|
|
|
|
return nil, err
|
|
|
|
|
}
|
|
|
|
|
defer CloseHandle(snapshot)
|
|
|
|
|
var procEntry ProcessEntry32
|
|
|
|
|
procEntry.Size = uint32(unsafe.Sizeof(procEntry))
|
|
|
|
|
if err = Process32First(snapshot, &procEntry); err != nil {
|
|
|
|
|
return nil, err
|
|
|
|
|
}
|
|
|
|
|
for {
|
|
|
|
|
if procEntry.ProcessID == uint32(pid) {
|
|
|
|
|
return &procEntry, nil
|
|
|
|
|
}
|
|
|
|
|
err = Process32Next(snapshot, &procEntry)
|
|
|
|
|
if err != nil {
|
|
|
|
|
return nil, err
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func Getppid() (ppid int) {
|
|
|
|
|
pe, err := getProcessEntry(Getpid())
|
|
|
|
|
if err != nil {
|
|
|
|
|
return -1
|
|
|
|
|
}
|
|
|
|
|
return int(pe.ParentProcessID)
|
|
|
|
|
}
|
2010-04-02 02:11:17 -06:00
|
|
|
|
2014-06-13 23:51:00 -06:00
|
|
|
// TODO(brainman): fix all needed for os
|
2014-07-17 01:02:46 -06:00
|
|
|
func Fchdir(fd Handle) (err error) { return EWINDOWS }
|
|
|
|
|
func Link(oldpath, newpath string) (err error) { return EWINDOWS }
|
|
|
|
|
func Symlink(path, link string) (err error) { return EWINDOWS }
|
2011-02-15 22:24:59 -07:00
|
|
|
|
2011-11-13 20:44:52 -07:00
|
|
|
func Fchmod(fd Handle, mode uint32) (err error) { return EWINDOWS }
|
|
|
|
|
func Chown(path string, uid int, gid int) (err error) { return EWINDOWS }
|
|
|
|
|
func Lchown(path string, uid int, gid int) (err error) { return EWINDOWS }
|
|
|
|
|
func Fchown(fd Handle, uid int, gid int) (err error) { return EWINDOWS }
|
2010-04-02 02:11:17 -06:00
|
|
|
|
2010-04-27 00:17:14 -06:00
|
|
|
func Getuid() (uid int) { return -1 }
|
|
|
|
|
func Geteuid() (euid int) { return -1 }
|
|
|
|
|
func Getgid() (gid int) { return -1 }
|
|
|
|
|
func Getegid() (egid int) { return -1 }
|
2011-11-13 20:44:52 -07:00
|
|
|
func Getgroups() (gids []int, err error) { return nil, EWINDOWS }
|
2012-02-13 19:51:38 -07:00
|
|
|
|
|
|
|
|
type Signal int
|
|
|
|
|
|
|
|
|
|
func (s Signal) Signal() {}
|
|
|
|
|
|
|
|
|
|
func (s Signal) String() string {
|
|
|
|
|
if 0 <= s && int(s) < len(signals) {
|
|
|
|
|
str := signals[s]
|
|
|
|
|
if str != "" {
|
|
|
|
|
return str
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return "signal " + itoa(int(s))
|
|
|
|
|
}
|
2014-07-17 01:02:46 -06:00
|
|
|
|
|
|
|
|
func LoadCreateSymbolicLink() error {
|
|
|
|
|
return procCreateSymbolicLinkW.Find()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Readlink returns the destination of the named symbolic link.
|
|
|
|
|
func Readlink(path string, buf []byte) (n int, err error) {
|
|
|
|
|
fd, err := CreateFile(StringToUTF16Ptr(path), GENERIC_READ, 0, nil, OPEN_EXISTING,
|
|
|
|
|
FILE_FLAG_OPEN_REPARSE_POINT|FILE_FLAG_BACKUP_SEMANTICS, 0)
|
|
|
|
|
if err != nil {
|
|
|
|
|
return -1, err
|
|
|
|
|
}
|
|
|
|
|
defer CloseHandle(fd)
|
|
|
|
|
|
|
|
|
|
rdbbuf := make([]byte, MAXIMUM_REPARSE_DATA_BUFFER_SIZE)
|
|
|
|
|
var bytesReturned uint32
|
|
|
|
|
err = DeviceIoControl(fd, FSCTL_GET_REPARSE_POINT, nil, 0, &rdbbuf[0], uint32(len(rdbbuf)), &bytesReturned, nil)
|
|
|
|
|
if err != nil {
|
|
|
|
|
return -1, err
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
rdb := (*reparseDataBuffer)(unsafe.Pointer(&rdbbuf[0]))
|
2015-01-05 17:47:37 -07:00
|
|
|
var s string
|
|
|
|
|
switch rdb.ReparseTag {
|
|
|
|
|
case IO_REPARSE_TAG_SYMLINK:
|
|
|
|
|
data := (*symbolicLinkReparseBuffer)(unsafe.Pointer(&rdb.reparseBuffer))
|
|
|
|
|
p := (*[0xffff]uint16)(unsafe.Pointer(&data.PathBuffer[0]))
|
|
|
|
|
s = UTF16ToString(p[data.PrintNameOffset/2 : (data.PrintNameLength-data.PrintNameOffset)/2])
|
|
|
|
|
case _IO_REPARSE_TAG_MOUNT_POINT:
|
|
|
|
|
data := (*mountPointReparseBuffer)(unsafe.Pointer(&rdb.reparseBuffer))
|
|
|
|
|
p := (*[0xffff]uint16)(unsafe.Pointer(&data.PathBuffer[0]))
|
|
|
|
|
s = UTF16ToString(p[data.PrintNameOffset/2 : (data.PrintNameLength-data.PrintNameOffset)/2])
|
|
|
|
|
default:
|
|
|
|
|
// the path is not a symlink or junction but another type of reparse
|
|
|
|
|
// point
|
2014-07-17 01:02:46 -06:00
|
|
|
return -1, ENOENT
|
|
|
|
|
}
|
|
|
|
|
n = copy(buf, []byte(s))
|
2015-01-05 17:47:37 -07:00
|
|
|
|
2014-07-17 01:02:46 -06:00
|
|
|
return n, nil
|
|
|
|
|
}
|
