mirror of https://github.com/gogits/gogs.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
989 lines
36 KiB
989 lines
36 KiB
// 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 windows |
|
|
|
import ( |
|
errorspkg "errors" |
|
"sync" |
|
"syscall" |
|
"unicode/utf16" |
|
"unsafe" |
|
) |
|
|
|
type Handle uintptr |
|
|
|
const InvalidHandle = ^Handle(0) |
|
|
|
// StringToUTF16 is deprecated. Use UTF16FromString instead. |
|
// If s contains a NUL byte this function panics instead of |
|
// returning an error. |
|
func StringToUTF16(s string) []uint16 { |
|
a, err := UTF16FromString(s) |
|
if err != nil { |
|
panic("windows: 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, syscall.EINVAL). |
|
func UTF16FromString(s string) ([]uint16, error) { |
|
for i := 0; i < len(s); i++ { |
|
if s[i] == 0 { |
|
return nil, syscall.EINVAL |
|
} |
|
} |
|
return utf16.Encode([]rune(s + "\x00")), nil |
|
} |
|
|
|
// UTF16ToString returns the UTF-8 encoding of the UTF-16 sequence s, |
|
// with a terminating NUL removed. |
|
func UTF16ToString(s []uint16) string { |
|
for i, v := range s { |
|
if v == 0 { |
|
s = s[0:i] |
|
break |
|
} |
|
} |
|
return string(utf16.Decode(s)) |
|
} |
|
|
|
// StringToUTF16Ptr is deprecated. Use UTF16PtrFromString instead. |
|
// If s contains a NUL byte this function panics instead of |
|
// returning an error. |
|
func StringToUTF16Ptr(s string) *uint16 { return &StringToUTF16(s)[0] } |
|
|
|
// 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, syscall.EINVAL). |
|
func UTF16PtrFromString(s string) (*uint16, error) { |
|
a, err := UTF16FromString(s) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return &a[0], nil |
|
} |
|
|
|
func Getpagesize() int { return 4096 } |
|
|
|
// Converts a Go function to a function pointer conforming |
|
// to the stdcall or cdecl calling convention. This is useful when |
|
// interoperating with Windows code requiring callbacks. |
|
// Implemented in runtime/syscall_windows.goc |
|
func NewCallback(fn interface{}) uintptr |
|
func NewCallbackCDecl(fn interface{}) uintptr |
|
|
|
// windows api calls |
|
|
|
//sys GetLastError() (lasterr error) |
|
//sys LoadLibrary(libname string) (handle Handle, err error) = LoadLibraryW |
|
//sys LoadLibraryEx(libname string, zero Handle, flags uintptr) (handle Handle, err error) = LoadLibraryExW |
|
//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 uintptr, msgid uint32, langid uint32, buf []uint16, args *byte) (n uint32, err error) = FormatMessageW |
|
//sys ExitProcess(exitcode uint32) |
|
//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] |
|
//sys findFirstFile1(name *uint16, data *win32finddata1) (handle Handle, err error) [failretval==InvalidHandle] = FindFirstFileW |
|
//sys findNextFile1(handle Handle, data *win32finddata1) (err error) = FindNextFileW |
|
//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 MoveFileEx(from *uint16, to *uint16, flags uint32) (err error) = MoveFileExW |
|
//sys GetComputerName(buf *uint16, n *uint32) (err error) = GetComputerNameW |
|
//sys GetComputerNameEx(nametype uint32, buf *uint16, n *uint32) (err error) = GetComputerNameExW |
|
//sys SetEndOfFile(handle Handle) (err error) |
|
//sys GetSystemTimeAsFileTime(time *Filetime) |
|
//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) |
|
//sys CancelIoEx(s Handle, o *Overlapped) (err error) |
|
//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) |
|
//sys GetProcessTimes(handle Handle, creationTime *Filetime, exitTime *Filetime, kernelTime *Filetime, userTime *Filetime) (err error) |
|
//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 |
|
//sys GetCommandLine() (cmd *uint16) = kernel32.GetCommandLineW |
|
//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 |
|
//sys GetLongPathName(path *uint16, buf *uint16, buflen uint32) (n uint32, err error) = kernel32.GetLongPathNameW |
|
//sys GetShortPathName(longpath *uint16, shortpath *uint16, buflen uint32) (n uint32, err error) = kernel32.GetShortPathNameW |
|
//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 |
|
//sys CertOpenStore(storeProvider uintptr, msgAndCertEncodingType uint32, cryptProv uintptr, flags uint32, para uintptr) (handle Handle, err error) [failretval==InvalidHandle] = crypt32.CertOpenStore |
|
//sys CertEnumCertificatesInStore(store Handle, prevContext *CertContext) (context *CertContext, err error) [failretval==nil] = crypt32.CertEnumCertificatesInStore |
|
//sys CertAddCertificateContextToStore(store Handle, certContext *CertContext, addDisposition uint32, storeContext **CertContext) (err error) = crypt32.CertAddCertificateContextToStore |
|
//sys CertCloseStore(store Handle, flags uint32) (err error) = crypt32.CertCloseStore |
|
//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 |
|
//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 |
|
//sys getCurrentProcessId() (pid uint32) = kernel32.GetCurrentProcessId |
|
//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 |
|
//sys ReadConsole(console Handle, buf *uint16, toread uint32, read *uint32, inputControl *byte) (err error) = kernel32.ReadConsoleW |
|
//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 |
|
//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 |
|
//sys GetCurrentThreadId() (id uint32) |
|
//sys CreateEvent(eventAttrs *syscall.SecurityAttributes, manualReset uint32, initialState uint32, name *uint16) (handle Handle, err error) = kernel32.CreateEventW |
|
//sys SetEvent(event Handle) (err error) = kernel32.SetEvent |
|
|
|
// syscall interface implementation for other packages |
|
|
|
func Exit(code int) { ExitProcess(uint32(code)) } |
|
|
|
func makeInheritSa() *SecurityAttributes { |
|
var sa SecurityAttributes |
|
sa.Length = uint32(unsafe.Sizeof(sa)) |
|
sa.InheritHandle = 1 |
|
return &sa |
|
} |
|
|
|
func Open(path string, mode int, perm uint32) (fd Handle, err error) { |
|
if len(path) == 0 { |
|
return InvalidHandle, ERROR_FILE_NOT_FOUND |
|
} |
|
pathp, err := UTF16PtrFromString(path) |
|
if err != nil { |
|
return InvalidHandle, err |
|
} |
|
var access uint32 |
|
switch mode & (O_RDONLY | O_WRONLY | O_RDWR) { |
|
case O_RDONLY: |
|
access = GENERIC_READ |
|
case O_WRONLY: |
|
access = GENERIC_WRITE |
|
case O_RDWR: |
|
access = GENERIC_READ | GENERIC_WRITE |
|
} |
|
if mode&O_CREAT != 0 { |
|
access |= GENERIC_WRITE |
|
} |
|
if mode&O_APPEND != 0 { |
|
access &^= GENERIC_WRITE |
|
access |= FILE_APPEND_DATA |
|
} |
|
sharemode := uint32(FILE_SHARE_READ | FILE_SHARE_WRITE) |
|
var sa *SecurityAttributes |
|
if mode&O_CLOEXEC == 0 { |
|
sa = makeInheritSa() |
|
} |
|
var createmode uint32 |
|
switch { |
|
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: |
|
createmode = TRUNCATE_EXISTING |
|
default: |
|
createmode = OPEN_EXISTING |
|
} |
|
h, e := CreateFile(pathp, access, sharemode, sa, createmode, FILE_ATTRIBUTE_NORMAL, 0) |
|
return h, e |
|
} |
|
|
|
func Read(fd Handle, p []byte) (n int, err error) { |
|
var done uint32 |
|
e := ReadFile(fd, p, &done, nil) |
|
if e != nil { |
|
if e == ERROR_BROKEN_PIPE { |
|
// NOTE(brainman): work around ERROR_BROKEN_PIPE is returned on reading EOF from stdin |
|
return 0, nil |
|
} |
|
return 0, e |
|
} |
|
if raceenabled { |
|
if done > 0 { |
|
raceWriteRange(unsafe.Pointer(&p[0]), int(done)) |
|
} |
|
raceAcquire(unsafe.Pointer(&ioSync)) |
|
} |
|
return int(done), nil |
|
} |
|
|
|
func Write(fd Handle, p []byte) (n int, err error) { |
|
if raceenabled { |
|
raceReleaseMerge(unsafe.Pointer(&ioSync)) |
|
} |
|
var done uint32 |
|
e := WriteFile(fd, p, &done, nil) |
|
if e != nil { |
|
return 0, e |
|
} |
|
if raceenabled && done > 0 { |
|
raceReadRange(unsafe.Pointer(&p[0]), int(done)) |
|
} |
|
return int(done), nil |
|
} |
|
|
|
var ioSync int64 |
|
|
|
func Seek(fd Handle, offset int64, whence int) (newoffset int64, err error) { |
|
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) |
|
// use GetFileType to check pipe, pipe can't do seek |
|
ft, _ := GetFileType(fd) |
|
if ft == FILE_TYPE_PIPE { |
|
return 0, syscall.EPIPE |
|
} |
|
rlo, e := SetFilePointer(fd, lo, &hi, w) |
|
if e != nil { |
|
return 0, e |
|
} |
|
return int64(hi)<<32 + int64(rlo), nil |
|
} |
|
|
|
func Close(fd Handle) (err error) { |
|
return CloseHandle(fd) |
|
} |
|
|
|
var ( |
|
Stdin = getStdHandle(STD_INPUT_HANDLE) |
|
Stdout = getStdHandle(STD_OUTPUT_HANDLE) |
|
Stderr = getStdHandle(STD_ERROR_HANDLE) |
|
) |
|
|
|
func getStdHandle(h int) (fd Handle) { |
|
r, _ := GetStdHandle(h) |
|
CloseOnExec(r) |
|
return r |
|
} |
|
|
|
const ImplementsGetwd = true |
|
|
|
func Getwd() (wd string, err error) { |
|
b := make([]uint16, 300) |
|
n, e := GetCurrentDirectory(uint32(len(b)), &b[0]) |
|
if e != nil { |
|
return "", e |
|
} |
|
return string(utf16.Decode(b[0:n])), nil |
|
} |
|
|
|
func Chdir(path string) (err error) { |
|
pathp, err := UTF16PtrFromString(path) |
|
if err != nil { |
|
return err |
|
} |
|
return SetCurrentDirectory(pathp) |
|
} |
|
|
|
func Mkdir(path string, mode uint32) (err error) { |
|
pathp, err := UTF16PtrFromString(path) |
|
if err != nil { |
|
return err |
|
} |
|
return CreateDirectory(pathp, nil) |
|
} |
|
|
|
func Rmdir(path string) (err error) { |
|
pathp, err := UTF16PtrFromString(path) |
|
if err != nil { |
|
return err |
|
} |
|
return RemoveDirectory(pathp) |
|
} |
|
|
|
func Unlink(path string) (err error) { |
|
pathp, err := UTF16PtrFromString(path) |
|
if err != nil { |
|
return err |
|
} |
|
return DeleteFile(pathp) |
|
} |
|
|
|
func Rename(oldpath, newpath string) (err error) { |
|
from, err := UTF16PtrFromString(oldpath) |
|
if err != nil { |
|
return err |
|
} |
|
to, err := UTF16PtrFromString(newpath) |
|
if err != nil { |
|
return err |
|
} |
|
return MoveFileEx(from, to, MOVEFILE_REPLACE_EXISTING) |
|
} |
|
|
|
func ComputerName() (name string, err error) { |
|
var n uint32 = MAX_COMPUTERNAME_LENGTH + 1 |
|
b := make([]uint16, n) |
|
e := GetComputerName(&b[0], &n) |
|
if e != nil { |
|
return "", e |
|
} |
|
return string(utf16.Decode(b[0:n])), nil |
|
} |
|
|
|
func Ftruncate(fd Handle, length int64) (err error) { |
|
curoffset, e := Seek(fd, 0, 1) |
|
if e != nil { |
|
return e |
|
} |
|
defer Seek(fd, curoffset, 0) |
|
_, e = Seek(fd, length, 0) |
|
if e != nil { |
|
return e |
|
} |
|
e = SetEndOfFile(fd) |
|
if e != nil { |
|
return e |
|
} |
|
return nil |
|
} |
|
|
|
func Gettimeofday(tv *Timeval) (err error) { |
|
var ft Filetime |
|
GetSystemTimeAsFileTime(&ft) |
|
*tv = NsecToTimeval(ft.Nanoseconds()) |
|
return nil |
|
} |
|
|
|
func Pipe(p []Handle) (err error) { |
|
if len(p) != 2 { |
|
return syscall.EINVAL |
|
} |
|
var r, w Handle |
|
e := CreatePipe(&r, &w, makeInheritSa(), 0) |
|
if e != nil { |
|
return e |
|
} |
|
p[0] = r |
|
p[1] = w |
|
return nil |
|
} |
|
|
|
func Utimes(path string, tv []Timeval) (err error) { |
|
if len(tv) != 2 { |
|
return syscall.EINVAL |
|
} |
|
pathp, e := UTF16PtrFromString(path) |
|
if e != nil { |
|
return e |
|
} |
|
h, e := CreateFile(pathp, |
|
FILE_WRITE_ATTRIBUTES, FILE_SHARE_WRITE, nil, |
|
OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0) |
|
if e != nil { |
|
return e |
|
} |
|
defer Close(h) |
|
a := NsecToFiletime(tv[0].Nanoseconds()) |
|
w := NsecToFiletime(tv[1].Nanoseconds()) |
|
return SetFileTime(h, nil, &a, &w) |
|
} |
|
|
|
func UtimesNano(path string, ts []Timespec) (err error) { |
|
if len(ts) != 2 { |
|
return syscall.EINVAL |
|
} |
|
pathp, e := UTF16PtrFromString(path) |
|
if e != nil { |
|
return e |
|
} |
|
h, e := CreateFile(pathp, |
|
FILE_WRITE_ATTRIBUTES, FILE_SHARE_WRITE, nil, |
|
OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0) |
|
if e != nil { |
|
return e |
|
} |
|
defer Close(h) |
|
a := NsecToFiletime(TimespecToNsec(ts[0])) |
|
w := NsecToFiletime(TimespecToNsec(ts[1])) |
|
return SetFileTime(h, nil, &a, &w) |
|
} |
|
|
|
func Fsync(fd Handle) (err error) { |
|
return FlushFileBuffers(fd) |
|
} |
|
|
|
func Chmod(path string, mode uint32) (err error) { |
|
if mode == 0 { |
|
return syscall.EINVAL |
|
} |
|
p, e := UTF16PtrFromString(path) |
|
if e != nil { |
|
return e |
|
} |
|
attrs, e := GetFileAttributes(p) |
|
if e != nil { |
|
return e |
|
} |
|
if mode&S_IWRITE != 0 { |
|
attrs &^= FILE_ATTRIBUTE_READONLY |
|
} else { |
|
attrs |= FILE_ATTRIBUTE_READONLY |
|
} |
|
return SetFileAttributes(p, attrs) |
|
} |
|
|
|
func LoadCancelIoEx() error { |
|
return procCancelIoEx.Find() |
|
} |
|
|
|
func LoadSetFileCompletionNotificationModes() error { |
|
return procSetFileCompletionNotificationModes.Find() |
|
} |
|
|
|
// net api calls |
|
|
|
const socket_error = uintptr(^uint32(0)) |
|
|
|
//sys WSAStartup(verreq uint32, data *WSAData) (sockerr error) = ws2_32.WSAStartup |
|
//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 |
|
//sys socket(af int32, typ int32, protocol int32) (handle Handle, err error) [failretval==InvalidHandle] = ws2_32.socket |
|
//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 |
|
//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 |
|
//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 |
|
//sys AcceptEx(ls Handle, as Handle, buf *byte, rxdatalen uint32, laddrlen uint32, raddrlen uint32, recvd *uint32, overlapped *Overlapped) (err error) = mswsock.AcceptEx |
|
//sys GetAcceptExSockaddrs(buf *byte, rxdatalen uint32, laddrlen uint32, raddrlen uint32, lrsa **RawSockaddrAny, lrsalen *int32, rrsa **RawSockaddrAny, rrsalen *int32) = mswsock.GetAcceptExSockaddrs |
|
//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 |
|
//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 |
|
//sys Ntohs(netshort uint16) (u uint16) = ws2_32.ntohs |
|
//sys GetProtoByName(name string) (p *Protoent, err error) [failretval==nil] = ws2_32.getprotobyname |
|
//sys DnsQuery(name string, qtype uint16, options uint32, extra *byte, qrs **DNSRecord, pr *byte) (status error) = dnsapi.DnsQuery_W |
|
//sys DnsRecordListFree(rl *DNSRecord, freetype uint32) = dnsapi.DnsRecordListFree |
|
//sys DnsNameCompare(name1 *uint16, name2 *uint16) (same bool) = dnsapi.DnsNameCompare_W |
|
//sys GetAddrInfoW(nodename *uint16, servicename *uint16, hints *AddrinfoW, result **AddrinfoW) (sockerr error) = ws2_32.GetAddrInfoW |
|
//sys FreeAddrInfoW(addrinfo *AddrinfoW) = ws2_32.FreeAddrInfoW |
|
//sys GetIfEntry(pIfRow *MibIfRow) (errcode error) = iphlpapi.GetIfEntry |
|
//sys GetAdaptersInfo(ai *IpAdapterInfo, ol *uint32) (errcode error) = iphlpapi.GetAdaptersInfo |
|
//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 |
|
//sys GetAdaptersAddresses(family uint32, flags uint32, reserved uintptr, adapterAddresses *IpAdapterAddresses, sizePointer *uint32) (errcode error) = iphlpapi.GetAdaptersAddresses |
|
//sys GetACP() (acp uint32) = kernel32.GetACP |
|
//sys MultiByteToWideChar(codePage uint32, dwFlags uint32, str *byte, nstr int32, wchar *uint16, nwchar int32) (nwrite int32, err error) = kernel32.MultiByteToWideChar |
|
|
|
// For testing: clients can set this flag to force |
|
// creation of IPv6 sockets to return EAFNOSUPPORT. |
|
var SocketDisableIPv6 bool |
|
|
|
type RawSockaddrInet4 struct { |
|
Family uint16 |
|
Port uint16 |
|
Addr [4]byte /* in_addr */ |
|
Zero [8]uint8 |
|
} |
|
|
|
type RawSockaddrInet6 struct { |
|
Family uint16 |
|
Port uint16 |
|
Flowinfo uint32 |
|
Addr [16]byte /* in6_addr */ |
|
Scope_id uint32 |
|
} |
|
|
|
type RawSockaddr struct { |
|
Family uint16 |
|
Data [14]int8 |
|
} |
|
|
|
type RawSockaddrAny struct { |
|
Addr RawSockaddr |
|
Pad [96]int8 |
|
} |
|
|
|
type Sockaddr interface { |
|
sockaddr() (ptr unsafe.Pointer, len int32, err error) // lowercase; only we can define Sockaddrs |
|
} |
|
|
|
type SockaddrInet4 struct { |
|
Port int |
|
Addr [4]byte |
|
raw RawSockaddrInet4 |
|
} |
|
|
|
func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, int32, error) { |
|
if sa.Port < 0 || sa.Port > 0xFFFF { |
|
return nil, 0, syscall.EINVAL |
|
} |
|
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] |
|
} |
|
return unsafe.Pointer(&sa.raw), int32(unsafe.Sizeof(sa.raw)), nil |
|
} |
|
|
|
type SockaddrInet6 struct { |
|
Port int |
|
ZoneId uint32 |
|
Addr [16]byte |
|
raw RawSockaddrInet6 |
|
} |
|
|
|
func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, int32, error) { |
|
if sa.Port < 0 || sa.Port > 0xFFFF { |
|
return nil, 0, syscall.EINVAL |
|
} |
|
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] |
|
} |
|
return unsafe.Pointer(&sa.raw), int32(unsafe.Sizeof(sa.raw)), nil |
|
} |
|
|
|
type SockaddrUnix struct { |
|
Name string |
|
} |
|
|
|
func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, int32, error) { |
|
// TODO(brainman): implement SockaddrUnix.sockaddr() |
|
return nil, 0, syscall.EWINDOWS |
|
} |
|
|
|
func (rsa *RawSockaddrAny) Sockaddr() (Sockaddr, error) { |
|
switch rsa.Addr.Family { |
|
case AF_UNIX: |
|
return nil, syscall.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] |
|
} |
|
return sa, nil |
|
|
|
case AF_INET6: |
|
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 |
|
} |
|
return nil, syscall.EAFNOSUPPORT |
|
} |
|
|
|
func Socket(domain, typ, proto int) (fd Handle, err error) { |
|
if domain == AF_INET6 && SocketDisableIPv6 { |
|
return InvalidHandle, syscall.EAFNOSUPPORT |
|
} |
|
return socket(int32(domain), int32(typ), int32(proto)) |
|
} |
|
|
|
func SetsockoptInt(fd Handle, level, opt int, value int) (err error) { |
|
v := int32(value) |
|
return Setsockopt(fd, int32(level), int32(opt), (*byte)(unsafe.Pointer(&v)), int32(unsafe.Sizeof(v))) |
|
} |
|
|
|
func Bind(fd Handle, sa Sockaddr) (err error) { |
|
ptr, n, err := sa.sockaddr() |
|
if err != nil { |
|
return err |
|
} |
|
return bind(fd, ptr, n) |
|
} |
|
|
|
func Connect(fd Handle, sa Sockaddr) (err error) { |
|
ptr, n, err := sa.sockaddr() |
|
if err != nil { |
|
return err |
|
} |
|
return connect(fd, ptr, n) |
|
} |
|
|
|
func Getsockname(fd Handle) (sa Sockaddr, err error) { |
|
var rsa RawSockaddrAny |
|
l := int32(unsafe.Sizeof(rsa)) |
|
if err = getsockname(fd, &rsa, &l); err != nil { |
|
return |
|
} |
|
return rsa.Sockaddr() |
|
} |
|
|
|
func Getpeername(fd Handle) (sa Sockaddr, err error) { |
|
var rsa RawSockaddrAny |
|
l := int32(unsafe.Sizeof(rsa)) |
|
if err = getpeername(fd, &rsa, &l); err != nil { |
|
return |
|
} |
|
return rsa.Sockaddr() |
|
} |
|
|
|
func Listen(s Handle, n int) (err error) { |
|
return listen(s, int32(n)) |
|
} |
|
|
|
func Shutdown(fd Handle, how int) (err error) { |
|
return shutdown(fd, int32(how)) |
|
} |
|
|
|
func WSASendto(s Handle, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, to Sockaddr, overlapped *Overlapped, croutine *byte) (err error) { |
|
rsa, l, err := to.sockaddr() |
|
if err != nil { |
|
return err |
|
} |
|
return WSASendTo(s, bufs, bufcnt, sent, flags, (*RawSockaddrAny)(unsafe.Pointer(rsa)), l, overlapped, croutine) |
|
} |
|
|
|
func LoadGetAddrInfo() error { |
|
return procGetAddrInfoW.Find() |
|
} |
|
|
|
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 |
|
} |
|
|
|
func connectEx(s Handle, name unsafe.Pointer, namelen int32, sendBuf *byte, sendDataLen uint32, bytesSent *uint32, overlapped *Overlapped) (err error) { |
|
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) |
|
if r1 == 0 { |
|
if e1 != 0 { |
|
err = error(e1) |
|
} else { |
|
err = syscall.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) |
|
} |
|
|
|
// Invented structures to support what package os expects. |
|
type Rusage struct { |
|
CreationTime Filetime |
|
ExitTime Filetime |
|
KernelTime Filetime |
|
UserTime Filetime |
|
} |
|
|
|
type WaitStatus struct { |
|
ExitCode uint32 |
|
} |
|
|
|
func (w WaitStatus) Exited() bool { return true } |
|
|
|
func (w WaitStatus) ExitStatus() int { return int(w.ExitCode) } |
|
|
|
func (w WaitStatus) Signal() Signal { return -1 } |
|
|
|
func (w WaitStatus) CoreDump() bool { return false } |
|
|
|
func (w WaitStatus) Stopped() bool { return false } |
|
|
|
func (w WaitStatus) Continued() bool { return false } |
|
|
|
func (w WaitStatus) StopSignal() Signal { return -1 } |
|
|
|
func (w WaitStatus) Signaled() bool { return false } |
|
|
|
func (w WaitStatus) TrapCause() int { return -1 } |
|
|
|
// Timespec is an invented structure on Windows, but here for |
|
// consistency with the corresponding package for other operating systems. |
|
type Timespec struct { |
|
Sec int64 |
|
Nsec int64 |
|
} |
|
|
|
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 |
|
} |
|
|
|
// TODO(brainman): fix all needed for net |
|
|
|
func Accept(fd Handle) (nfd Handle, sa Sockaddr, err error) { return 0, nil, syscall.EWINDOWS } |
|
func Recvfrom(fd Handle, p []byte, flags int) (n int, from Sockaddr, err error) { |
|
return 0, nil, syscall.EWINDOWS |
|
} |
|
func Sendto(fd Handle, p []byte, flags int, to Sockaddr) (err error) { return syscall.EWINDOWS } |
|
func SetsockoptTimeval(fd Handle, level, opt int, tv *Timeval) (err error) { return syscall.EWINDOWS } |
|
|
|
// 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. |
|
|
|
type Linger struct { |
|
Onoff int32 |
|
Linger int32 |
|
} |
|
|
|
type sysLinger struct { |
|
Onoff uint16 |
|
Linger uint16 |
|
} |
|
|
|
type IPMreq struct { |
|
Multiaddr [4]byte /* in_addr */ |
|
Interface [4]byte /* in_addr */ |
|
} |
|
|
|
type IPv6Mreq struct { |
|
Multiaddr [16]byte /* in6_addr */ |
|
Interface uint32 |
|
} |
|
|
|
func GetsockoptInt(fd Handle, level, opt int) (int, error) { return -1, syscall.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))) |
|
} |
|
|
|
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) |
|
} |
|
func SetsockoptIPMreq(fd Handle, level, opt int, mreq *IPMreq) (err error) { |
|
return Setsockopt(fd, int32(level), int32(opt), (*byte)(unsafe.Pointer(mreq)), int32(unsafe.Sizeof(*mreq))) |
|
} |
|
func SetsockoptIPv6Mreq(fd Handle, level, opt int, mreq *IPv6Mreq) (err error) { |
|
return syscall.EWINDOWS |
|
} |
|
|
|
func Getpid() (pid int) { return int(getCurrentProcessId()) } |
|
|
|
func FindFirstFile(name *uint16, data *Win32finddata) (handle Handle, err error) { |
|
// 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 |
|
} |
|
|
|
func FindNextFile(handle Handle, data *Win32finddata) (err error) { |
|
var data1 win32finddata1 |
|
err = findNextFile1(handle, &data1) |
|
if err == nil { |
|
copyFindData(data, &data1) |
|
} |
|
return |
|
} |
|
|
|
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) |
|
} |
|
|
|
// TODO(brainman): fix all needed for os |
|
func Fchdir(fd Handle) (err error) { return syscall.EWINDOWS } |
|
func Link(oldpath, newpath string) (err error) { return syscall.EWINDOWS } |
|
func Symlink(path, link string) (err error) { return syscall.EWINDOWS } |
|
|
|
func Fchmod(fd Handle, mode uint32) (err error) { return syscall.EWINDOWS } |
|
func Chown(path string, uid int, gid int) (err error) { return syscall.EWINDOWS } |
|
func Lchown(path string, uid int, gid int) (err error) { return syscall.EWINDOWS } |
|
func Fchown(fd Handle, uid int, gid int) (err error) { return syscall.EWINDOWS } |
|
|
|
func Getuid() (uid int) { return -1 } |
|
func Geteuid() (euid int) { return -1 } |
|
func Getgid() (gid int) { return -1 } |
|
func Getegid() (egid int) { return -1 } |
|
func Getgroups() (gids []int, err error) { return nil, syscall.EWINDOWS } |
|
|
|
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)) |
|
} |
|
|
|
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])) |
|
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 |
|
return -1, syscall.ENOENT |
|
} |
|
n = copy(buf, []byte(s)) |
|
|
|
return n, nil |
|
}
|
|
|