mirror of
https://github.com/superseriousbusiness/gotosocial.git
synced 2024-11-01 15:00:00 +00:00
66f09a8d93
Bumps [modernc.org/sqlite](https://gitlab.com/cznic/sqlite) from 1.22.0 to 1.22.1. - [Release notes](https://gitlab.com/cznic/sqlite/tags) - [Commits](https://gitlab.com/cznic/sqlite/compare/v1.22.0...v1.22.1) --- updated-dependencies: - dependency-name: modernc.org/sqlite dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
6273 lines
152 KiB
Go
6273 lines
152 KiB
Go
// Copyright 2020 The Libc Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package libc // import "modernc.org/libc"
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"math"
|
|
"os"
|
|
"os/exec"
|
|
"os/user"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
"sync/atomic"
|
|
"syscall"
|
|
gotime "time"
|
|
"unicode"
|
|
"unicode/utf16"
|
|
"unsafe"
|
|
|
|
"modernc.org/libc/errno"
|
|
"modernc.org/libc/fcntl"
|
|
"modernc.org/libc/limits"
|
|
"modernc.org/libc/stdio"
|
|
"modernc.org/libc/sys/stat"
|
|
"modernc.org/libc/sys/types"
|
|
"modernc.org/libc/time"
|
|
"modernc.org/libc/unistd"
|
|
)
|
|
|
|
// Keep these outside of the var block otherwise go generate will miss them.
|
|
var X__imp__environ = EnvironP()
|
|
var X__imp__wenviron = uintptr(unsafe.Pointer(&wenviron))
|
|
var X_imp___environ = EnvironP()
|
|
var X_iob [stdio.X_IOB_ENTRIES]stdio.FILE
|
|
|
|
var Xtimezone long // extern long timezone;
|
|
|
|
var (
|
|
iobMap = map[uintptr]int32{} // &_iob[fd] -> fd
|
|
wenvValid bool
|
|
wenviron uintptr // &winEnviron[0]
|
|
winEnviron = []uintptr{0}
|
|
)
|
|
|
|
func init() {
|
|
for i := range X_iob {
|
|
iobMap[uintptr(unsafe.Pointer(&X_iob[i]))] = int32(i)
|
|
}
|
|
}
|
|
|
|
func winGetObject(stream uintptr) interface{} {
|
|
if fd, ok := iobMap[stream]; ok {
|
|
f, _ := fdToFile(fd)
|
|
return f
|
|
}
|
|
|
|
return getObject(stream)
|
|
}
|
|
|
|
type (
|
|
long = int32
|
|
ulong = uint32
|
|
)
|
|
|
|
var (
|
|
modkernel32 = syscall.NewLazyDLL("kernel32.dll")
|
|
//--
|
|
procAreFileApisANSI = modkernel32.NewProc("AreFileApisANSI")
|
|
procCopyFileW = modkernel32.NewProc("CopyFileW")
|
|
procCreateEventA = modkernel32.NewProc("CreateEventA")
|
|
procCreateEventW = modkernel32.NewProc("CreateEventW")
|
|
procCreateFileA = modkernel32.NewProc("CreateFileA")
|
|
procCreateFileMappingW = modkernel32.NewProc("CreateFileMappingW")
|
|
procCreateFileW = modkernel32.NewProc("CreateFileW")
|
|
procCreateHardLinkW = modkernel32.NewProc("CreateHardLinkW")
|
|
procCreatePipe = modkernel32.NewProc("CreatePipe")
|
|
procCreateProcessA = modkernel32.NewProc("CreateProcessA")
|
|
procCreateProcessW = modkernel32.NewProc("CreateProcessW")
|
|
procCreateThread = modkernel32.NewProc("CreateThread")
|
|
procDeleteCriticalSection = modkernel32.NewProc("DeleteCriticalSection")
|
|
procDeviceIoControl = modkernel32.NewProc("DeviceIoControl")
|
|
procDuplicateHandle = modkernel32.NewProc("DuplicateHandle")
|
|
procEnterCriticalSection = modkernel32.NewProc("EnterCriticalSection")
|
|
procFindClose = modkernel32.NewProc("FindClose")
|
|
procFindFirstFileExW = modkernel32.NewProc("FindFirstFileExW")
|
|
procFindFirstFileW = modkernel32.NewProc("FindFirstFileW")
|
|
procFindNextFileW = modkernel32.NewProc("FindNextFileW")
|
|
procFormatMessageW = modkernel32.NewProc("FormatMessageW")
|
|
procGetACP = modkernel32.NewProc("GetACP")
|
|
procGetCommState = modkernel32.NewProc("GetCommState")
|
|
procGetComputerNameExW = modkernel32.NewProc("GetComputerNameExW")
|
|
procGetConsoleCP = modkernel32.NewProc("GetConsoleCP")
|
|
procGetConsoleScreenBufferInfo = modkernel32.NewProc("GetConsoleScreenBufferInfo")
|
|
procGetCurrentProcess = modkernel32.NewProc("GetCurrentProcess")
|
|
procGetCurrentProcessId = modkernel32.NewProc("GetCurrentProcessId")
|
|
procGetCurrentThread = modkernel32.NewProc("GetCurrentThread")
|
|
procGetCurrentThreadId = modkernel32.NewProc("GetCurrentThreadId")
|
|
procGetEnvironmentVariableA = modkernel32.NewProc("GetEnvironmentVariableA")
|
|
procGetEnvironmentVariableW = modkernel32.NewProc("GetEnvironmentVariableW")
|
|
procGetExitCodeProcess = modkernel32.NewProc("GetExitCodeProcess")
|
|
procGetExitCodeThread = modkernel32.NewProc("GetExitCodeThread")
|
|
procGetFileAttributesA = modkernel32.NewProc("GetFileAttributesA")
|
|
procGetFileAttributesExA = modkernel32.NewProc("GetFileAttributesExA")
|
|
procGetFileAttributesExW = modkernel32.NewProc("GetFileAttributesExW")
|
|
procGetFileInformationByHandle = modkernel32.NewProc("GetFileInformationByHandle")
|
|
procGetFileSize = modkernel32.NewProc("GetFileSize")
|
|
procGetFullPathNameW = modkernel32.NewProc("GetFullPathNameW")
|
|
procGetLastError = modkernel32.NewProc("GetLastError")
|
|
procGetLogicalDriveStringsA = modkernel32.NewProc("GetLogicalDriveStringsA")
|
|
procGetModuleFileNameW = modkernel32.NewProc("GetModuleFileNameW")
|
|
procGetModuleHandleA = modkernel32.NewProc("GetModuleHandleA")
|
|
procGetModuleHandleW = modkernel32.NewProc("GetModuleHandleW")
|
|
procGetPrivateProfileStringA = modkernel32.NewProc("GetPrivateProfileStringA")
|
|
procGetProcAddress = modkernel32.NewProc("GetProcAddress")
|
|
procGetProcessHeap = modkernel32.NewProc("GetProcessHeap")
|
|
procGetSystemInfo = modkernel32.NewProc("GetSystemInfo")
|
|
procGetSystemTime = modkernel32.NewProc("GetSystemTime")
|
|
procGetSystemTimeAsFileTime = modkernel32.NewProc("GetSystemTimeAsFileTime")
|
|
procGetTempFileNameW = modkernel32.NewProc("GetTempFileNameW")
|
|
procGetTickCount = modkernel32.NewProc("GetTickCount")
|
|
procGetVersionExA = modkernel32.NewProc("GetVersionExA")
|
|
procGetVersionExW = modkernel32.NewProc("GetVersionExW")
|
|
procGetVolumeInformationA = modkernel32.NewProc("GetVolumeInformationA")
|
|
procGetVolumeInformationW = modkernel32.NewProc("GetVolumeInformationW")
|
|
procHeapAlloc = modkernel32.NewProc("HeapAlloc")
|
|
procHeapFree = modkernel32.NewProc("HeapFree")
|
|
procInitializeCriticalSection = modkernel32.NewProc("InitializeCriticalSection")
|
|
procLeaveCriticalSection = modkernel32.NewProc("LeaveCriticalSection")
|
|
procLockFile = modkernel32.NewProc("LockFile")
|
|
procLockFileEx = modkernel32.NewProc("LockFileEx")
|
|
procLstrlenW = modkernel32.NewProc("lstrlenW")
|
|
procMapViewOfFile = modkernel32.NewProc("MapViewOfFile")
|
|
procMoveFileW = modkernel32.NewProc("MoveFileW")
|
|
procMultiByteToWideChar = modkernel32.NewProc("MultiByteToWideChar")
|
|
procOpenEventA = modkernel32.NewProc("OpenEventA")
|
|
procPeekConsoleInputW = modkernel32.NewProc("PeekConsoleInputW")
|
|
procPeekNamedPipe = modkernel32.NewProc("PeekNamedPipe")
|
|
procQueryPerformanceCounter = modkernel32.NewProc("QueryPerformanceCounter")
|
|
procQueryPerformanceFrequency = modkernel32.NewProc("QueryPerformanceFrequency")
|
|
procReadConsoleW = modkernel32.NewProc("ReadConsoleW")
|
|
procReadFile = modkernel32.NewProc("ReadFile")
|
|
procResetEvent = modkernel32.NewProc("ResetEvent")
|
|
procSearchPathW = modkernel32.NewProc("SearchPathW")
|
|
procSetConsoleCtrlHandler = modkernel32.NewProc("SetConsoleCtrlHandler")
|
|
procSetConsoleMode = modkernel32.NewProc("SetConsoleMode")
|
|
procSetConsoleTextAttribute = modkernel32.NewProc("SetConsoleTextAttribute")
|
|
procSetEvent = modkernel32.NewProc("SetEvent")
|
|
procSetFilePointer = modkernel32.NewProc("SetFilePointer")
|
|
procSleepEx = modkernel32.NewProc("SleepEx")
|
|
procSystemTimeToFileTime = modkernel32.NewProc("SystemTimeToFileTime")
|
|
procTerminateThread = modkernel32.NewProc("TerminateThread")
|
|
procUnlockFile = modkernel32.NewProc("UnlockFile")
|
|
procUnlockFileEx = modkernel32.NewProc("UnlockFileEx")
|
|
procWaitForSingleObjectEx = modkernel32.NewProc("WaitForSingleObjectEx")
|
|
procWideCharToMultiByte = modkernel32.NewProc("WideCharToMultiByte")
|
|
procWriteConsoleA = modkernel32.NewProc("WriteConsoleA")
|
|
procWriteConsoleW = modkernel32.NewProc("WriteConsoleW")
|
|
procWriteFile = modkernel32.NewProc("WriteFile")
|
|
|
|
// procSetConsoleCP = modkernel32.NewProc("SetConsoleCP")
|
|
// procSetThreadPriority = modkernel32.NewProc("SetThreadPriority")
|
|
//--
|
|
|
|
modadvapi = syscall.NewLazyDLL("advapi32.dll")
|
|
//--
|
|
procAccessCheck = modadvapi.NewProc("AccessCheck")
|
|
procGetAclInformation = modadvapi.NewProc("GetAclInformation")
|
|
procGetFileSecurityA = modadvapi.NewProc("GetFileSecurityA")
|
|
procGetFileSecurityW = modadvapi.NewProc("GetFileSecurityW")
|
|
procGetSecurityDescriptorDacl = modadvapi.NewProc("GetSecurityDescriptorDacl")
|
|
procGetSecurityDescriptorOwner = modadvapi.NewProc("GetSecurityDescriptorOwner")
|
|
procGetSidIdentifierAuthority = modadvapi.NewProc("GetSidIdentifierAuthority")
|
|
procGetSidLengthRequired = modadvapi.NewProc("GetSidLengthRequired")
|
|
procGetSidSubAuthority = modadvapi.NewProc("GetSidSubAuthority")
|
|
procImpersonateSelf = modadvapi.NewProc("ImpersonateSelf")
|
|
procInitializeSid = modadvapi.NewProc("InitializeSid")
|
|
procOpenThreadToken = modadvapi.NewProc("OpenThreadToken")
|
|
procRevertToSelf = modadvapi.NewProc("RevertToSelf")
|
|
//--
|
|
|
|
modws2_32 = syscall.NewLazyDLL("ws2_32.dll")
|
|
//--
|
|
procWSAStartup = modws2_32.NewProc("WSAStartup")
|
|
//--
|
|
|
|
moduser32 = syscall.NewLazyDLL("user32.dll")
|
|
//--
|
|
procCreateWindowExW = moduser32.NewProc("CreateWindowExW")
|
|
procMsgWaitForMultipleObjectsEx = moduser32.NewProc("MsgWaitForMultipleObjectsEx")
|
|
procPeekMessageW = moduser32.NewProc("PeekMessageW")
|
|
procRegisterClassW = moduser32.NewProc("RegisterClassW")
|
|
procUnregisterClassW = moduser32.NewProc("UnregisterClassW")
|
|
procWaitForInputIdle = moduser32.NewProc("WaitForInputIdle")
|
|
//--
|
|
|
|
netapi = syscall.NewLazyDLL("netapi32.dll")
|
|
procNetGetDCName = netapi.NewProc("NetGetDCName")
|
|
procNetUserGetInfo = netapi.NewProc("NetUserGetInfo")
|
|
|
|
userenvapi = syscall.NewLazyDLL("userenv.dll")
|
|
procGetProfilesDirectoryW = userenvapi.NewProc("GetProfilesDirectoryW")
|
|
)
|
|
|
|
var (
|
|
threadCallback uintptr
|
|
)
|
|
|
|
func init() {
|
|
isWindows = true
|
|
threadCallback = syscall.NewCallback(ThreadProc)
|
|
}
|
|
|
|
// ---------------------------------
|
|
// Windows filehandle-to-fd mapping
|
|
// so the lib-c interface contract looks
|
|
// like normal fds being passed around
|
|
// but we're mapping them back and forth to
|
|
// native windows file handles (syscall.Handle)
|
|
//
|
|
|
|
var EBADF = errors.New("EBADF")
|
|
|
|
var w_nextFd int32 = 42
|
|
var w_fdLock sync.Mutex
|
|
var w_fd_to_file = map[int32]*file{}
|
|
|
|
type file struct {
|
|
_fd int32
|
|
hadErr bool
|
|
t uintptr
|
|
syscall.Handle
|
|
}
|
|
|
|
func addFile(hdl syscall.Handle, fd int32) uintptr {
|
|
var f = file{_fd: fd, Handle: hdl}
|
|
w_fdLock.Lock()
|
|
defer w_fdLock.Unlock()
|
|
w_fd_to_file[fd] = &f
|
|
f.t = addObject(&f)
|
|
return f.t
|
|
}
|
|
|
|
func remFile(f *file) {
|
|
removeObject(f.t)
|
|
w_fdLock.Lock()
|
|
defer w_fdLock.Unlock()
|
|
delete(w_fd_to_file, f._fd)
|
|
}
|
|
|
|
func fdToFile(fd int32) (*file, bool) {
|
|
w_fdLock.Lock()
|
|
defer w_fdLock.Unlock()
|
|
f, ok := w_fd_to_file[fd]
|
|
return f, ok
|
|
}
|
|
|
|
// Wrap the windows handle up tied to a unique fd
|
|
func wrapFdHandle(hdl syscall.Handle) (uintptr, int32) {
|
|
newFd := atomic.AddInt32(&w_nextFd, 1)
|
|
return addFile(hdl, newFd), newFd
|
|
}
|
|
|
|
func (f *file) err() bool {
|
|
return f.hadErr
|
|
}
|
|
|
|
func (f *file) setErr() {
|
|
f.hadErr = true
|
|
}
|
|
|
|
// -----------------------------------
|
|
// On windows we have to fetch these
|
|
//
|
|
// stdout, stdin, sterr
|
|
//
|
|
// Using the windows specific GetStdHandle
|
|
// they're mapped to the standard fds (0,1,2)
|
|
// Note: it's possible they don't exist
|
|
// if the app has been built for a GUI only
|
|
// target in windows. If that's the case
|
|
// panic seems like the only reasonable option
|
|
// ------------------------------
|
|
|
|
func newFile(t *TLS, fd int32) uintptr {
|
|
|
|
if fd == unistd.STDIN_FILENO {
|
|
h, err := syscall.GetStdHandle(syscall.STD_INPUT_HANDLE)
|
|
if err != nil {
|
|
panic("no console")
|
|
}
|
|
return addFile(h, fd)
|
|
}
|
|
if fd == unistd.STDOUT_FILENO {
|
|
h, err := syscall.GetStdHandle(syscall.STD_OUTPUT_HANDLE)
|
|
if err != nil {
|
|
panic("no console")
|
|
}
|
|
return addFile(h, fd)
|
|
}
|
|
if fd == unistd.STDERR_FILENO {
|
|
h, err := syscall.GetStdHandle(syscall.STD_ERROR_HANDLE)
|
|
if err != nil {
|
|
panic("no console")
|
|
}
|
|
return addFile(h, fd)
|
|
}
|
|
|
|
// should not get here -- unless newFile
|
|
// is being used from somewhere we don't know about
|
|
// to originate fds.
|
|
|
|
panic("unknown fd source")
|
|
return 0
|
|
}
|
|
|
|
func (f *file) close(t *TLS) int32 {
|
|
remFile(f)
|
|
err := syscall.Close(f.Handle)
|
|
if err != nil {
|
|
return (-1) // EOF
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func fwrite(fd int32, b []byte) (int, error) {
|
|
if fd == unistd.STDOUT_FILENO {
|
|
return write(b)
|
|
}
|
|
|
|
f, ok := fdToFile(fd)
|
|
if !ok {
|
|
return -1, EBADF
|
|
}
|
|
|
|
if dmesgs {
|
|
dmesg("%v: fd %v: %s", origin(1), fd, b)
|
|
}
|
|
return syscall.Write(f.Handle, b)
|
|
}
|
|
|
|
// int fprintf(FILE *stream, const char *format, ...);
|
|
func Xfprintf(t *TLS, stream, format, args uintptr) int32 {
|
|
f, ok := winGetObject(stream).(*file)
|
|
if !ok {
|
|
t.setErrno(errno.EBADF)
|
|
return -1
|
|
}
|
|
|
|
n, _ := fwrite(f._fd, printf(format, args))
|
|
return int32(n)
|
|
}
|
|
|
|
// int usleep(useconds_t usec);
|
|
func Xusleep(t *TLS, usec types.Useconds_t) int32 {
|
|
gotime.Sleep(gotime.Microsecond * gotime.Duration(usec))
|
|
return 0
|
|
}
|
|
|
|
// int getrusage(int who, struct rusage *usage);
|
|
func Xgetrusage(t *TLS, who int32, usage uintptr) int32 {
|
|
panic(todo(""))
|
|
// if _, _, err := unix.Syscall(unix.SYS_GETRUSAGE, uintptr(who), usage, 0); err != 0 {
|
|
// t.setErrno(err)
|
|
// return -1
|
|
// }
|
|
|
|
// return 0
|
|
}
|
|
|
|
// int lstat(const char *pathname, struct stat *statbuf);
|
|
func Xlstat(t *TLS, pathname, statbuf uintptr) int32 {
|
|
return Xlstat64(t, pathname, statbuf)
|
|
}
|
|
|
|
// int stat(const char *pathname, struct stat *statbuf);
|
|
func Xstat(t *TLS, pathname, statbuf uintptr) int32 {
|
|
return Xstat64(t, pathname, statbuf)
|
|
}
|
|
|
|
// int chdir(const char *path);
|
|
func Xchdir(t *TLS, path uintptr) int32 {
|
|
err := syscall.Chdir(GoString(path))
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
return -1
|
|
}
|
|
|
|
if dmesgs {
|
|
dmesg("%v: %q: ok", origin(1), GoString(path))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
var localtime time.Tm
|
|
|
|
// struct tm *localtime(const time_t *timep);
|
|
func Xlocaltime(_ *TLS, timep uintptr) uintptr {
|
|
loc := getLocalLocation()
|
|
ut := *(*time.Time_t)(unsafe.Pointer(timep))
|
|
t := gotime.Unix(int64(ut), 0).In(loc)
|
|
localtime.Ftm_sec = int32(t.Second())
|
|
localtime.Ftm_min = int32(t.Minute())
|
|
localtime.Ftm_hour = int32(t.Hour())
|
|
localtime.Ftm_mday = int32(t.Day())
|
|
localtime.Ftm_mon = int32(t.Month() - 1)
|
|
localtime.Ftm_year = int32(t.Year() - 1900)
|
|
localtime.Ftm_wday = int32(t.Weekday())
|
|
localtime.Ftm_yday = int32(t.YearDay())
|
|
localtime.Ftm_isdst = Bool32(isTimeDST(t))
|
|
return uintptr(unsafe.Pointer(&localtime))
|
|
}
|
|
|
|
// struct tm *localtime(const time_t *timep);
|
|
func X_localtime64(_ *TLS, timep uintptr) uintptr {
|
|
return Xlocaltime(nil, timep)
|
|
}
|
|
|
|
// struct tm *localtime_r(const time_t *timep, struct tm *result);
|
|
func Xlocaltime_r(_ *TLS, timep, result uintptr) uintptr {
|
|
panic(todo(""))
|
|
// loc := getLocalLocation()
|
|
// ut := *(*unix.Time_t)(unsafe.Pointer(timep))
|
|
// t := gotime.Unix(int64(ut), 0).In(loc)
|
|
// (*time.Tm)(unsafe.Pointer(result)).Ftm_sec = int32(t.Second())
|
|
// (*time.Tm)(unsafe.Pointer(result)).Ftm_min = int32(t.Minute())
|
|
// (*time.Tm)(unsafe.Pointer(result)).Ftm_hour = int32(t.Hour())
|
|
// (*time.Tm)(unsafe.Pointer(result)).Ftm_mday = int32(t.Day())
|
|
// (*time.Tm)(unsafe.Pointer(result)).Ftm_mon = int32(t.Month() - 1)
|
|
// (*time.Tm)(unsafe.Pointer(result)).Ftm_year = int32(t.Year() - 1900)
|
|
// (*time.Tm)(unsafe.Pointer(result)).Ftm_wday = int32(t.Weekday())
|
|
// (*time.Tm)(unsafe.Pointer(result)).Ftm_yday = int32(t.YearDay())
|
|
// (*time.Tm)(unsafe.Pointer(result)).Ftm_isdst = Bool32(isTimeDST(t))
|
|
// return result
|
|
}
|
|
|
|
// int _wopen(
|
|
//
|
|
// const wchar_t *filename,
|
|
// int oflag [,
|
|
// int pmode]
|
|
//
|
|
// );
|
|
func X_wopen(t *TLS, pathname uintptr, flags int32, args uintptr) int32 {
|
|
var mode types.Mode_t
|
|
if args != 0 {
|
|
mode = *(*types.Mode_t)(unsafe.Pointer(args))
|
|
}
|
|
s := goWideString(pathname)
|
|
h, err := syscall.Open(GoString(pathname), int(flags), uint32(mode))
|
|
if err != nil {
|
|
if dmesgs {
|
|
dmesg("%v: %q %#x: %v", origin(1), s, flags, err)
|
|
}
|
|
|
|
t.setErrno(err)
|
|
return 0
|
|
}
|
|
|
|
_, n := wrapFdHandle(h)
|
|
if dmesgs {
|
|
dmesg("%v: %q flags %#x mode %#o: fd %v", origin(1), s, flags, mode, n)
|
|
}
|
|
return n
|
|
}
|
|
|
|
// int open(const char *pathname, int flags, ...);
|
|
func Xopen(t *TLS, pathname uintptr, flags int32, args uintptr) int32 {
|
|
return Xopen64(t, pathname, flags, args)
|
|
}
|
|
|
|
// int open(const char *pathname, int flags, ...);
|
|
func Xopen64(t *TLS, pathname uintptr, flags int32, cmode uintptr) int32 {
|
|
|
|
var mode types.Mode_t
|
|
if cmode != 0 {
|
|
mode = (types.Mode_t)(VaUint32(&cmode))
|
|
}
|
|
// fdcwd := fcntl.AT_FDCWD
|
|
h, err := syscall.Open(GoString(pathname), int(flags), uint32(mode))
|
|
if err != nil {
|
|
|
|
if dmesgs {
|
|
dmesg("%v: %q %#x: %v", origin(1), GoString(pathname), flags, err)
|
|
}
|
|
|
|
t.setErrno(err)
|
|
return -1
|
|
}
|
|
|
|
_, n := wrapFdHandle(h)
|
|
if dmesgs {
|
|
dmesg("%v: %q flags %#x mode %#o: fd %v", origin(1), GoString(pathname), flags, mode, n)
|
|
}
|
|
return n
|
|
}
|
|
|
|
// off_t lseek(int fd, off_t offset, int whence);
|
|
func Xlseek(t *TLS, fd int32, offset types.Off_t, whence int32) types.Off_t {
|
|
return types.Off_t(Xlseek64(t, fd, offset, whence))
|
|
}
|
|
|
|
func whenceStr(whence int32) string {
|
|
switch whence {
|
|
case syscall.FILE_CURRENT:
|
|
return "SEEK_CUR"
|
|
case syscall.FILE_END:
|
|
return "SEEK_END"
|
|
case syscall.FILE_BEGIN:
|
|
return "SEEK_SET"
|
|
default:
|
|
return fmt.Sprintf("whence(%d)", whence)
|
|
}
|
|
}
|
|
|
|
var fsyncStatbuf stat.Stat
|
|
|
|
// int fsync(int fd);
|
|
func Xfsync(t *TLS, fd int32) int32 {
|
|
|
|
f, ok := fdToFile(fd)
|
|
if !ok {
|
|
t.setErrno(errno.EBADF)
|
|
return -1
|
|
}
|
|
err := syscall.FlushFileBuffers(f.Handle)
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
return -1
|
|
}
|
|
|
|
if dmesgs {
|
|
dmesg("%v: %d: ok", origin(1), fd)
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// long sysconf(int name);
|
|
func Xsysconf(t *TLS, name int32) long {
|
|
panic(todo(""))
|
|
// switch name {
|
|
// case unistd.X_SC_PAGESIZE:
|
|
// return long(unix.Getpagesize())
|
|
// }
|
|
|
|
// panic(todo(""))
|
|
}
|
|
|
|
// int close(int fd);
|
|
func Xclose(t *TLS, fd int32) int32 {
|
|
|
|
f, ok := fdToFile(fd)
|
|
if !ok {
|
|
t.setErrno(errno.EBADF)
|
|
return -1
|
|
}
|
|
|
|
err := syscall.Close(f.Handle)
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
return -1
|
|
}
|
|
|
|
if dmesgs {
|
|
dmesg("%v: %d: ok", origin(1), fd)
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// char *getcwd(char *buf, size_t size);
|
|
func Xgetcwd(t *TLS, buf uintptr, size types.Size_t) uintptr {
|
|
|
|
b := make([]uint16, size)
|
|
n, err := syscall.GetCurrentDirectory(uint32(len(b)), &b[0])
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
return 0
|
|
}
|
|
// to bytes
|
|
var wd = []byte(string(utf16.Decode(b[0:n])))
|
|
if types.Size_t(len(wd)) > size {
|
|
t.setErrno(errno.ERANGE)
|
|
return 0
|
|
}
|
|
|
|
copy((*RawMem)(unsafe.Pointer(buf))[:], wd)
|
|
(*RawMem)(unsafe.Pointer(buf))[len(wd)] = 0
|
|
|
|
if dmesgs {
|
|
dmesg("%v: %q: ok", origin(1), GoString(buf))
|
|
}
|
|
return buf
|
|
}
|
|
|
|
// int fstat(int fd, struct stat *statbuf);
|
|
func Xfstat(t *TLS, fd int32, statbuf uintptr) int32 {
|
|
return Xfstat64(t, fd, statbuf)
|
|
}
|
|
|
|
// int ftruncate(int fd, off_t length);
|
|
func Xftruncate(t *TLS, fd int32, length types.Off_t) int32 {
|
|
return Xftruncate64(t, fd, length)
|
|
}
|
|
|
|
// int fcntl(int fd, int cmd, ... /* arg */ );
|
|
func Xfcntl(t *TLS, fd, cmd int32, args uintptr) int32 {
|
|
return Xfcntl64(t, fd, cmd, args)
|
|
}
|
|
|
|
// int _read( // https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/read?view=msvc-160
|
|
//
|
|
// int const fd,
|
|
// void * const buffer,
|
|
// unsigned const buffer_size
|
|
//
|
|
// );
|
|
func Xread(t *TLS, fd int32, buf uintptr, count uint32) int32 {
|
|
f, ok := fdToFile(fd)
|
|
if !ok {
|
|
t.setErrno(errno.EBADF)
|
|
return -1
|
|
}
|
|
|
|
var obuf = ((*RawMem)(unsafe.Pointer(buf)))[:count]
|
|
n, err := syscall.Read(f.Handle, obuf)
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
return -1
|
|
}
|
|
|
|
if dmesgs {
|
|
// dmesg("%v: %d %#x: %#x\n%s", origin(1), fd, count, n, hex.Dump(GoBytes(buf, int(n))))
|
|
dmesg("%v: %d %#x: %#x", origin(1), fd, count, n)
|
|
}
|
|
return int32(n)
|
|
}
|
|
|
|
// int _write( // https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/write?view=msvc-160
|
|
//
|
|
// int fd,
|
|
// const void *buffer,
|
|
// unsigned int count
|
|
//
|
|
// );
|
|
func Xwrite(t *TLS, fd int32, buf uintptr, count uint32) int32 {
|
|
f, ok := fdToFile(fd)
|
|
if !ok {
|
|
t.setErrno(errno.EBADF)
|
|
return -1
|
|
}
|
|
|
|
var obuf = ((*RawMem)(unsafe.Pointer(buf)))[:count]
|
|
n, err := syscall.Write(f.Handle, obuf)
|
|
if err != nil {
|
|
if dmesgs {
|
|
dmesg("%v: fd %v, count %#x: %v", origin(1), fd, count, err)
|
|
}
|
|
t.setErrno(err)
|
|
return -1
|
|
}
|
|
|
|
if dmesgs {
|
|
// dmesg("%v: %d %#x: %#x\n%s", origin(1), fd, count, n, hex.Dump(GoBytes(buf, int(n))))
|
|
dmesg("%v: %d %#x: %#x", origin(1), fd, count, n)
|
|
}
|
|
return int32(n)
|
|
}
|
|
|
|
// int fchmod(int fd, mode_t mode);
|
|
func Xfchmod(t *TLS, fd int32, mode types.Mode_t) int32 {
|
|
panic(todo(""))
|
|
// if _, _, err := unix.Syscall(unix.SYS_FCHMOD, uintptr(fd), uintptr(mode), 0); err != 0 {
|
|
// t.setErrno(err)
|
|
// return -1
|
|
// }
|
|
|
|
// if dmesgs {
|
|
// dmesg("%v: %d %#o: ok", origin(1), fd, mode)
|
|
// }
|
|
// return 0
|
|
}
|
|
|
|
// // int fchown(int fd, uid_t owner, gid_t group);
|
|
// func Xfchown(t *TLS, fd int32, owner types.Uid_t, group types.Gid_t) int32 {
|
|
// if _, _, err := unix.Syscall(unix.SYS_FCHOWN, uintptr(fd), uintptr(owner), uintptr(group)); err != 0 {
|
|
// t.setErrno(err)
|
|
// return -1
|
|
// }
|
|
//
|
|
// return 0
|
|
// }
|
|
|
|
// // uid_t geteuid(void);
|
|
// func Xgeteuid(t *TLS) types.Uid_t {
|
|
// n, _, _ := unix.Syscall(unix.SYS_GETEUID, 0, 0, 0)
|
|
// return types.Uid_t(n)
|
|
// }
|
|
|
|
// int munmap(void *addr, size_t length);
|
|
func Xmunmap(t *TLS, addr uintptr, length types.Size_t) int32 {
|
|
panic(todo(""))
|
|
// if _, _, err := unix.Syscall(unix.SYS_MUNMAP, addr, uintptr(length), 0); err != 0 {
|
|
// t.setErrno(err)
|
|
// return -1
|
|
// }
|
|
|
|
// return 0
|
|
}
|
|
|
|
// int gettimeofday(struct timeval *tv, struct timezone *tz);
|
|
func Xgettimeofday(t *TLS, tv, tz uintptr) int32 {
|
|
panic(todo(""))
|
|
// if tz != 0 {
|
|
// panic(todo(""))
|
|
// }
|
|
|
|
// var tvs unix.Timeval
|
|
// err := unix.Gettimeofday(&tvs)
|
|
// if err != nil {
|
|
// t.setErrno(err)
|
|
// return -1
|
|
// }
|
|
|
|
// *(*unix.Timeval)(unsafe.Pointer(tv)) = tvs
|
|
// return 0
|
|
}
|
|
|
|
// int getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen);
|
|
func Xgetsockopt(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
// if _, _, err := unix.Syscall6(unix.SYS_GETSOCKOPT, uintptr(sockfd), uintptr(level), uintptr(optname), optval, optlen, 0); err != 0 {
|
|
// t.setErrno(err)
|
|
// return -1
|
|
// }
|
|
|
|
// return 0
|
|
}
|
|
|
|
// // int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);
|
|
func Xsetsockopt(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int ioctl(int fd, unsigned long request, ...);
|
|
func Xioctl(t *TLS, fd int32, request ulong, va uintptr) int32 {
|
|
panic(todo(""))
|
|
// var argp uintptr
|
|
// if va != 0 {
|
|
// argp = VaUintptr(&va)
|
|
// }
|
|
// n, _, err := unix.Syscall(unix.SYS_IOCTL, uintptr(fd), uintptr(request), argp)
|
|
// if err != 0 {
|
|
// t.setErrno(err)
|
|
// return -1
|
|
// }
|
|
|
|
// return int32(n)
|
|
}
|
|
|
|
// int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
|
|
func Xselect(t *TLS, nfds int32, readfds, writefds, exceptfds, timeout uintptr) int32 {
|
|
panic(todo(""))
|
|
// n, err := unix.Select(
|
|
// int(nfds),
|
|
// (*unix.FdSet)(unsafe.Pointer(readfds)),
|
|
// (*unix.FdSet)(unsafe.Pointer(writefds)),
|
|
// (*unix.FdSet)(unsafe.Pointer(exceptfds)),
|
|
// (*unix.Timeval)(unsafe.Pointer(timeout)),
|
|
// )
|
|
// if err != nil {
|
|
// t.setErrno(err)
|
|
// return -1
|
|
// }
|
|
|
|
// return int32(n)
|
|
}
|
|
|
|
// int mkfifo(const char *pathname, mode_t mode);
|
|
func Xmkfifo(t *TLS, pathname uintptr, mode types.Mode_t) int32 {
|
|
panic(todo(""))
|
|
// if err := unix.Mkfifo(GoString(pathname), mode); err != nil {
|
|
// t.setErrno(err)
|
|
// return -1
|
|
// }
|
|
//
|
|
// return 0
|
|
}
|
|
|
|
// mode_t umask(mode_t mask);
|
|
func Xumask(t *TLS, mask types.Mode_t) types.Mode_t {
|
|
panic(todo(""))
|
|
// n, _, _ := unix.Syscall(unix.SYS_UMASK, uintptr(mask), 0, 0)
|
|
// return types.Mode_t(n)
|
|
}
|
|
|
|
// int execvp(const char *file, char *const argv[]);
|
|
func Xexecvp(t *TLS, file, argv uintptr) int32 {
|
|
panic(todo(""))
|
|
// if _, _, err := unix.Syscall(unix.SYS_EXECVE, file, argv, Environ()); err != 0 {
|
|
// t.setErrno(err)
|
|
// return -1
|
|
// }
|
|
//
|
|
// return 0
|
|
}
|
|
|
|
// pid_t waitpid(pid_t pid, int *wstatus, int options);
|
|
func Xwaitpid(t *TLS, pid types.Pid_t, wstatus uintptr, optname int32) types.Pid_t {
|
|
panic(todo(""))
|
|
// n, _, err := unix.Syscall6(unix.SYS_WAIT4, uintptr(pid), wstatus, uintptr(optname), 0, 0, 0)
|
|
// if err != 0 {
|
|
// t.setErrno(err)
|
|
// return -1
|
|
// }
|
|
//
|
|
// return types.Pid_t(n)
|
|
}
|
|
|
|
// int uname(struct utsname *buf);
|
|
func Xuname(t *TLS, buf uintptr) int32 {
|
|
panic(todo(""))
|
|
// if _, _, err := unix.Syscall(unix.SYS_UNAME, buf, 0, 0); err != 0 {
|
|
// t.setErrno(err)
|
|
// return -1
|
|
// }
|
|
//
|
|
// return 0
|
|
}
|
|
|
|
// int getrlimit(int resource, struct rlimit *rlim);
|
|
func Xgetrlimit(t *TLS, resource int32, rlim uintptr) int32 {
|
|
return Xgetrlimit64(t, resource, rlim)
|
|
}
|
|
|
|
// int setrlimit(int resource, const struct rlimit *rlim);
|
|
func Xsetrlimit(t *TLS, resource int32, rlim uintptr) int32 {
|
|
return Xsetrlimit64(t, resource, rlim)
|
|
}
|
|
|
|
// int setrlimit(int resource, const struct rlimit *rlim);
|
|
func Xsetrlimit64(t *TLS, resource int32, rlim uintptr) int32 {
|
|
panic(todo(""))
|
|
// if _, _, err := unix.Syscall(unix.SYS_SETRLIMIT, uintptr(resource), uintptr(rlim), 0); err != 0 {
|
|
// t.setErrno(err)
|
|
// return -1
|
|
// }
|
|
//
|
|
// return 0
|
|
}
|
|
|
|
// // uid_t getuid(void);
|
|
// func Xgetuid(t *TLS) types.Uid_t {
|
|
// return types.Uid_t(os.Getuid())
|
|
// }
|
|
|
|
// pid_t getpid(void);
|
|
func Xgetpid(t *TLS) int32 {
|
|
return int32(os.Getpid())
|
|
}
|
|
|
|
// int system(const char *command);
|
|
func Xsystem(t *TLS, command uintptr) int32 {
|
|
s := GoString(command)
|
|
if command == 0 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
cmd := exec.Command("sh", "-c", s)
|
|
cmd.Stdout = os.Stdout
|
|
cmd.Stderr = os.Stderr
|
|
err := cmd.Run()
|
|
if err != nil {
|
|
ps := err.(*exec.ExitError)
|
|
return int32(ps.ExitCode())
|
|
}
|
|
|
|
return 0
|
|
}
|
|
|
|
// var staticGetpwuid pwd.Passwd
|
|
//
|
|
// func init() {
|
|
// atExit = append(atExit, func() { closePasswd(&staticGetpwuid) })
|
|
// }
|
|
//
|
|
// func closePasswd(p *pwd.Passwd) {
|
|
// Xfree(nil, p.Fpw_name)
|
|
// Xfree(nil, p.Fpw_passwd)
|
|
// Xfree(nil, p.Fpw_gecos)
|
|
// Xfree(nil, p.Fpw_dir)
|
|
// Xfree(nil, p.Fpw_shell)
|
|
// *p = pwd.Passwd{}
|
|
// }
|
|
|
|
// struct passwd *getpwuid(uid_t uid);
|
|
func Xgetpwuid(t *TLS, uid uint32) uintptr {
|
|
panic(todo(""))
|
|
// f, err := os.Open("/etc/passwd")
|
|
// if err != nil {
|
|
// panic(todo("", err))
|
|
// }
|
|
//
|
|
// defer f.Close()
|
|
//
|
|
// sid := strconv.Itoa(int(uid))
|
|
// sc := bufio.NewScanner(f)
|
|
// for sc.Scan() {
|
|
// // eg. "root:x:0:0:root:/root:/bin/bash"
|
|
// a := strings.Split(sc.Text(), ":")
|
|
// if len(a) < 7 {
|
|
// panic(todo(""))
|
|
// }
|
|
//
|
|
// if a[2] == sid {
|
|
// uid, err := strconv.Atoi(a[2])
|
|
// if err != nil {
|
|
// panic(todo(""))
|
|
// }
|
|
//
|
|
// gid, err := strconv.Atoi(a[3])
|
|
// if err != nil {
|
|
// panic(todo(""))
|
|
// }
|
|
//
|
|
// closePasswd(&staticGetpwuid)
|
|
// gecos := a[4]
|
|
// if strings.Contains(gecos, ",") {
|
|
// a := strings.Split(gecos, ",")
|
|
// gecos = a[0]
|
|
// }
|
|
// initPasswd(t, &staticGetpwuid, a[0], a[1], uint32(uid), uint32(gid), gecos, a[5], a[6])
|
|
// return uintptr(unsafe.Pointer(&staticGetpwuid))
|
|
// }
|
|
// }
|
|
//
|
|
// if sc.Err() != nil {
|
|
// panic(todo(""))
|
|
// }
|
|
//
|
|
// return 0
|
|
}
|
|
|
|
// func initPasswd(t *TLS, p *pwd.Passwd, name, pwd string, uid, gid uint32, gecos, dir, shell string) {
|
|
// p.Fpw_name = cString(t, name)
|
|
// p.Fpw_passwd = cString(t, pwd)
|
|
// p.Fpw_uid = uid
|
|
// p.Fpw_gid = gid
|
|
// p.Fpw_gecos = cString(t, gecos)
|
|
// p.Fpw_dir = cString(t, dir)
|
|
// p.Fpw_shell = cString(t, shell)
|
|
// }
|
|
|
|
// int setvbuf(FILE *stream, char *buf, int mode, size_t size);
|
|
func Xsetvbuf(t *TLS, stream, buf uintptr, mode int32, size types.Size_t) int32 {
|
|
return 0 //TODO
|
|
}
|
|
|
|
// int raise(int sig);
|
|
func Xraise(t *TLS, sig int32) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int backtrace(void **buffer, int size);
|
|
func Xbacktrace(t *TLS, buf uintptr, size int32) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// void backtrace_symbols_fd(void *const *buffer, int size, int fd);
|
|
func Xbacktrace_symbols_fd(t *TLS, buffer uintptr, size, fd int32) {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int fileno(FILE *stream);
|
|
func Xfileno(t *TLS, stream uintptr) int32 {
|
|
if stream == 0 {
|
|
t.setErrno(errno.EBADF)
|
|
return -1
|
|
}
|
|
|
|
f, ok := winGetObject(stream).(*file)
|
|
if !ok {
|
|
t.setErrno(errno.EBADF)
|
|
return -1
|
|
}
|
|
return f._fd
|
|
}
|
|
|
|
// var staticGetpwnam pwd.Passwd
|
|
//
|
|
// func init() {
|
|
// atExit = append(atExit, func() { closePasswd(&staticGetpwnam) })
|
|
// }
|
|
//
|
|
// // struct passwd *getpwnam(const char *name);
|
|
// func Xgetpwnam(t *TLS, name uintptr) uintptr {
|
|
// f, err := os.Open("/etc/passwd")
|
|
// if err != nil {
|
|
// panic(todo("", err))
|
|
// }
|
|
//
|
|
// defer f.Close()
|
|
//
|
|
// sname := GoString(name)
|
|
// sc := bufio.NewScanner(f)
|
|
// for sc.Scan() {
|
|
// // eg. "root:x:0:0:root:/root:/bin/bash"
|
|
// a := strings.Split(sc.Text(), ":")
|
|
// if len(a) < 7 {
|
|
// panic(todo(""))
|
|
// }
|
|
//
|
|
// if a[0] == sname {
|
|
// uid, err := strconv.Atoi(a[2])
|
|
// if err != nil {
|
|
// panic(todo(""))
|
|
// }
|
|
//
|
|
// gid, err := strconv.Atoi(a[3])
|
|
// if err != nil {
|
|
// panic(todo(""))
|
|
// }
|
|
//
|
|
// closePasswd(&staticGetpwnam)
|
|
// gecos := a[4]
|
|
// if strings.Contains(gecos, ",") {
|
|
// a := strings.Split(gecos, ",")
|
|
// gecos = a[0]
|
|
// }
|
|
// initPasswd(t, &staticGetpwnam, a[0], a[1], uint32(uid), uint32(gid), gecos, a[5], a[6])
|
|
// return uintptr(unsafe.Pointer(&staticGetpwnam))
|
|
// }
|
|
// }
|
|
//
|
|
// if sc.Err() != nil {
|
|
// panic(todo(""))
|
|
// }
|
|
//
|
|
// return 0
|
|
// }
|
|
//
|
|
// var staticGetgrnam grp.Group
|
|
//
|
|
// func init() {
|
|
// atExit = append(atExit, func() { closeGroup(&staticGetgrnam) })
|
|
// }
|
|
//
|
|
// // struct group *getgrnam(const char *name);
|
|
// func Xgetgrnam(t *TLS, name uintptr) uintptr {
|
|
// f, err := os.Open("/etc/group")
|
|
// if err != nil {
|
|
// panic(todo(""))
|
|
// }
|
|
//
|
|
// defer f.Close()
|
|
//
|
|
// sname := GoString(name)
|
|
// sc := bufio.NewScanner(f)
|
|
// for sc.Scan() {
|
|
// // eg. "root:x:0:"
|
|
// a := strings.Split(sc.Text(), ":")
|
|
// if len(a) < 4 {
|
|
// panic(todo(""))
|
|
// }
|
|
//
|
|
// if a[0] == sname {
|
|
// closeGroup(&staticGetgrnam)
|
|
// gid, err := strconv.Atoi(a[2])
|
|
// if err != nil {
|
|
// panic(todo(""))
|
|
// }
|
|
//
|
|
// var names []string
|
|
// if a[3] != "" {
|
|
// names = strings.Split(a[3], ",")
|
|
// }
|
|
// initGroup(t, &staticGetgrnam, a[0], a[1], uint32(gid), names)
|
|
// return uintptr(unsafe.Pointer(&staticGetgrnam))
|
|
// }
|
|
// }
|
|
//
|
|
// if sc.Err() != nil {
|
|
// panic(todo(""))
|
|
// }
|
|
//
|
|
// return 0
|
|
// }
|
|
//
|
|
// func closeGroup(p *grp.Group) {
|
|
// Xfree(nil, p.Fgr_name)
|
|
// Xfree(nil, p.Fgr_passwd)
|
|
// if p.Fgr_mem != 0 {
|
|
// panic(todo(""))
|
|
// }
|
|
//
|
|
// *p = grp.Group{}
|
|
// }
|
|
//
|
|
// func initGroup(t *TLS, p *grp.Group, name, pwd string, gid uint32, names []string) {
|
|
// p.Fgr_name = cString(t, name)
|
|
// p.Fgr_passwd = cString(t, pwd)
|
|
// p.Fgr_gid = gid
|
|
// p.Fgr_mem = 0
|
|
// if len(names) != 0 {
|
|
// panic(todo("%q %q %v %q %v", name, pwd, gid, names, len(names)))
|
|
// }
|
|
// }
|
|
//
|
|
// func init() {
|
|
// atExit = append(atExit, func() { closeGroup(&staticGetgrgid) })
|
|
// }
|
|
//
|
|
// var staticGetgrgid grp.Group
|
|
//
|
|
// // struct group *getgrgid(gid_t gid);
|
|
// func Xgetgrgid(t *TLS, gid uint32) uintptr {
|
|
// f, err := os.Open("/etc/group")
|
|
// if err != nil {
|
|
// panic(todo(""))
|
|
// }
|
|
//
|
|
// defer f.Close()
|
|
//
|
|
// sid := strconv.Itoa(int(gid))
|
|
// sc := bufio.NewScanner(f)
|
|
// for sc.Scan() {
|
|
// // eg. "root:x:0:"
|
|
// a := strings.Split(sc.Text(), ":")
|
|
// if len(a) < 4 {
|
|
// panic(todo(""))
|
|
// }
|
|
//
|
|
// if a[2] == sid {
|
|
// closeGroup(&staticGetgrgid)
|
|
// var names []string
|
|
// if a[3] != "" {
|
|
// names = strings.Split(a[3], ",")
|
|
// }
|
|
// initGroup(t, &staticGetgrgid, a[0], a[1], gid, names)
|
|
// return uintptr(unsafe.Pointer(&staticGetgrgid))
|
|
// }
|
|
// }
|
|
//
|
|
// if sc.Err() != nil {
|
|
// panic(todo(""))
|
|
// }
|
|
//
|
|
// return 0
|
|
// }
|
|
|
|
// int mkstemps(char *template, int suffixlen);
|
|
func Xmkstemps(t *TLS, template uintptr, suffixlen int32) int32 {
|
|
return Xmkstemps64(t, template, suffixlen)
|
|
}
|
|
|
|
// int mkstemps(char *template, int suffixlen);
|
|
func Xmkstemps64(t *TLS, template uintptr, suffixlen int32) int32 {
|
|
panic(todo(""))
|
|
// len := uintptr(Xstrlen(t, template))
|
|
// x := template + uintptr(len-6) - uintptr(suffixlen)
|
|
// for i := uintptr(0); i < 6; i++ {
|
|
// if *(*byte)(unsafe.Pointer(x + i)) != 'X' {
|
|
// t.setErrno(errno.EINVAL)
|
|
// return -1
|
|
// }
|
|
// }
|
|
//
|
|
// fd, err := tempFile(template, x)
|
|
// if err != 0 {
|
|
// t.setErrno(err)
|
|
// return -1
|
|
// }
|
|
//
|
|
// return int32(fd)
|
|
}
|
|
|
|
// int mkstemp(char *template);
|
|
func Xmkstemp64(t *TLS, template uintptr) int32 {
|
|
return Xmkstemps64(t, template, 0)
|
|
}
|
|
|
|
// func newFtsent(t *TLS, info int, path string, stat *unix.Stat_t, err syscall.Errno) (r *fts.FTSENT) {
|
|
// var statp uintptr
|
|
// if stat != nil {
|
|
// statp = Xmalloc(t, types.Size_t(unsafe.Sizeof(unix.Stat_t{})))
|
|
// if statp == 0 {
|
|
// panic("OOM")
|
|
// }
|
|
//
|
|
// *(*unix.Stat_t)(unsafe.Pointer(statp)) = *stat
|
|
// }
|
|
// csp := CString(path)
|
|
// if csp == 0 {
|
|
// panic("OOM")
|
|
// }
|
|
//
|
|
// return &fts.FTSENT{
|
|
// Ffts_info: uint16(info),
|
|
// Ffts_path: csp,
|
|
// Ffts_pathlen: uint16(len(path)),
|
|
// Ffts_statp: statp,
|
|
// Ffts_errno: int32(err),
|
|
// }
|
|
// }
|
|
//
|
|
// func newCFtsent(t *TLS, info int, path string, stat *unix.Stat_t, err syscall.Errno) uintptr {
|
|
// p := Xcalloc(t, types.Size_t(unsafe.Sizeof(fts.FTSENT{})))
|
|
// if p == 0 {
|
|
// panic("OOM")
|
|
// }
|
|
//
|
|
// *(*fts.FTSENT)(unsafe.Pointer(p)) = *newFtsent(t, info, path, stat, err)
|
|
// return p
|
|
// }
|
|
//
|
|
// func ftsentClose(t *TLS, p uintptr) {
|
|
// Xfree(t, (*fts.FTSENT)(unsafe.Pointer(p)).Ffts_path)
|
|
// Xfree(t, (*fts.FTSENT)(unsafe.Pointer(p)).Ffts_statp)
|
|
// }
|
|
|
|
type ftstream struct {
|
|
s []uintptr
|
|
x int
|
|
}
|
|
|
|
// func (f *ftstream) close(t *TLS) {
|
|
// for _, p := range f.s {
|
|
// ftsentClose(t, p)
|
|
// Xfree(t, p)
|
|
// }
|
|
// *f = ftstream{}
|
|
// }
|
|
//
|
|
// // FTS *fts_open(char * const *path_argv, int options, int (*compar)(const FTSENT **, const FTSENT **));
|
|
// func Xfts_open(t *TLS, path_argv uintptr, options int32, compar uintptr) uintptr {
|
|
// return Xfts64_open(t, path_argv, options, compar)
|
|
// }
|
|
|
|
// FTS *fts_open(char * const *path_argv, int options, int (*compar)(const FTSENT **, const FTSENT **));
|
|
func Xfts64_open(t *TLS, path_argv uintptr, options int32, compar uintptr) uintptr {
|
|
panic(todo(""))
|
|
// f := &ftstream{}
|
|
//
|
|
// var walk func(string)
|
|
// walk = func(path string) {
|
|
// var fi os.FileInfo
|
|
// var err error
|
|
// switch {
|
|
// case options&fts.FTS_LOGICAL != 0:
|
|
// fi, err = os.Stat(path)
|
|
// case options&fts.FTS_PHYSICAL != 0:
|
|
// fi, err = os.Lstat(path)
|
|
// default:
|
|
// panic(todo(""))
|
|
// }
|
|
//
|
|
// if err != nil {
|
|
// panic(todo(""))
|
|
// }
|
|
//
|
|
// var statp *unix.Stat_t
|
|
// if options&fts.FTS_NOSTAT == 0 {
|
|
// var stat unix.Stat_t
|
|
// switch {
|
|
// case options&fts.FTS_LOGICAL != 0:
|
|
// if err := unix.Stat(path, &stat); err != nil {
|
|
// panic(todo(""))
|
|
// }
|
|
// case options&fts.FTS_PHYSICAL != 0:
|
|
// if err := unix.Lstat(path, &stat); err != nil {
|
|
// panic(todo(""))
|
|
// }
|
|
// default:
|
|
// panic(todo(""))
|
|
// }
|
|
//
|
|
// statp = &stat
|
|
// }
|
|
//
|
|
// out:
|
|
// switch {
|
|
// case fi.IsDir():
|
|
// f.s = append(f.s, newCFtsent(t, fts.FTS_D, path, statp, 0))
|
|
// g, err := os.Open(path)
|
|
// switch x := err.(type) {
|
|
// case nil:
|
|
// // ok
|
|
// case *os.PathError:
|
|
// f.s = append(f.s, newCFtsent(t, fts.FTS_DNR, path, statp, errno.EACCES))
|
|
// break out
|
|
// default:
|
|
// panic(todo("%q: %v %T", path, x, x))
|
|
// }
|
|
//
|
|
// names, err := g.Readdirnames(-1)
|
|
// g.Close()
|
|
// if err != nil {
|
|
// panic(todo(""))
|
|
// }
|
|
//
|
|
// for _, name := range names {
|
|
// walk(path + "/" + name)
|
|
// if f == nil {
|
|
// break out
|
|
// }
|
|
// }
|
|
//
|
|
// f.s = append(f.s, newCFtsent(t, fts.FTS_DP, path, statp, 0))
|
|
// default:
|
|
// info := fts.FTS_F
|
|
// if fi.Mode()&os.ModeSymlink != 0 {
|
|
// info = fts.FTS_SL
|
|
// }
|
|
// switch {
|
|
// case statp != nil:
|
|
// f.s = append(f.s, newCFtsent(t, info, path, statp, 0))
|
|
// case options&fts.FTS_NOSTAT != 0:
|
|
// f.s = append(f.s, newCFtsent(t, fts.FTS_NSOK, path, nil, 0))
|
|
// default:
|
|
// panic(todo(""))
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
// for {
|
|
// p := *(*uintptr)(unsafe.Pointer(path_argv))
|
|
// if p == 0 {
|
|
// if f == nil {
|
|
// return 0
|
|
// }
|
|
//
|
|
// if compar != 0 {
|
|
// panic(todo(""))
|
|
// }
|
|
//
|
|
// return addObject(f)
|
|
// }
|
|
//
|
|
// walk(GoString(p))
|
|
// path_argv += unsafe.Sizeof(uintptr(0))
|
|
// }
|
|
}
|
|
|
|
// FTSENT *fts_read(FTS *ftsp);
|
|
func Xfts_read(t *TLS, ftsp uintptr) uintptr {
|
|
return Xfts64_read(t, ftsp)
|
|
}
|
|
|
|
// FTSENT *fts_read(FTS *ftsp);
|
|
func Xfts64_read(t *TLS, ftsp uintptr) uintptr {
|
|
panic(todo(""))
|
|
// f := winGetObject(ftsp).(*ftstream)
|
|
// if f.x == len(f.s) {
|
|
// t.setErrno(0)
|
|
// return 0
|
|
// }
|
|
//
|
|
// r := f.s[f.x]
|
|
// if e := (*fts.FTSENT)(unsafe.Pointer(r)).Ffts_errno; e != 0 {
|
|
// t.setErrno(e)
|
|
// }
|
|
// f.x++
|
|
// return r
|
|
}
|
|
|
|
// int fts_close(FTS *ftsp);
|
|
func Xfts_close(t *TLS, ftsp uintptr) int32 {
|
|
return Xfts64_close(t, ftsp)
|
|
}
|
|
|
|
// int fts_close(FTS *ftsp);
|
|
func Xfts64_close(t *TLS, ftsp uintptr) int32 {
|
|
panic(todo(""))
|
|
// winGetObject(ftsp).(*ftstream).close(t)
|
|
// removeObject(ftsp)
|
|
// return 0
|
|
}
|
|
|
|
// void tzset (void);
|
|
func Xtzset(t *TLS) {
|
|
//TODO
|
|
}
|
|
|
|
var strerrorBuf [256]byte
|
|
|
|
// char *strerror(int errnum);
|
|
func Xstrerror(t *TLS, errnum int32) uintptr {
|
|
copy((*RawMem)(unsafe.Pointer(&strerrorBuf[0]))[:len(strerrorBuf):len(strerrorBuf)], fmt.Sprintf("errno %d\x00", errnum))
|
|
return uintptr(unsafe.Pointer(&strerrorBuf[0]))
|
|
}
|
|
|
|
// void *dlopen(const char *filename, int flags);
|
|
func Xdlopen(t *TLS, filename uintptr, flags int32) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// char *dlerror(void);
|
|
func Xdlerror(t *TLS) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int dlclose(void *handle);
|
|
func Xdlclose(t *TLS, handle uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// void *dlsym(void *handle, const char *symbol);
|
|
func Xdlsym(t *TLS, handle, symbol uintptr) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// void perror(const char *s);
|
|
func Xperror(t *TLS, s uintptr) {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int pclose(FILE *stream);
|
|
func Xpclose(t *TLS, stream uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
var gai_strerrorBuf [100]byte
|
|
|
|
// const char *gai_strerror(int errcode);
|
|
func Xgai_strerror(t *TLS, errcode int32) uintptr {
|
|
copy(gai_strerrorBuf[:], fmt.Sprintf("gai error %d\x00", errcode))
|
|
return uintptr(unsafe.Pointer(&gai_strerrorBuf))
|
|
}
|
|
|
|
// int tcgetattr(int fd, struct termios *termios_p);
|
|
func Xtcgetattr(t *TLS, fd int32, termios_p uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int tcsetattr(int fd, int optional_actions, const struct termios *termios_p);
|
|
func Xtcsetattr(t *TLS, fd, optional_actions int32, termios_p uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// // speed_t cfgetospeed(const struct termios *termios_p);
|
|
// func Xcfgetospeed(t *TLS, termios_p uintptr) termios.Speed_t {
|
|
// panic(todo(""))
|
|
// }
|
|
|
|
// int cfsetospeed(struct termios *termios_p, speed_t speed);
|
|
func Xcfsetospeed(t *TLS, termios_p uintptr, speed uint32) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int cfsetispeed(struct termios *termios_p, speed_t speed);
|
|
func Xcfsetispeed(t *TLS, termios_p uintptr, speed uint32) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// pid_t fork(void);
|
|
func Xfork(t *TLS) int32 {
|
|
t.setErrno(errno.ENOSYS)
|
|
return -1
|
|
}
|
|
|
|
// char *setlocale(int category, const char *locale);
|
|
func Xsetlocale(t *TLS, category int32, locale uintptr) uintptr {
|
|
return 0 //TODO
|
|
}
|
|
|
|
// // char *nl_langinfo(nl_item item);
|
|
// func Xnl_langinfo(t *TLS, item langinfo.Nl_item) uintptr {
|
|
// panic(todo(""))
|
|
// }
|
|
|
|
// FILE *popen(const char *command, const char *type);
|
|
func Xpopen(t *TLS, command, type1 uintptr) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// char *realpath(const char *path, char *resolved_path);
|
|
func Xrealpath(t *TLS, path, resolved_path uintptr) uintptr {
|
|
s, err := filepath.EvalSymlinks(GoString(path))
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
if dmesgs {
|
|
dmesg("%v: %q: %v", origin(1), GoString(path), err)
|
|
}
|
|
t.setErrno(errno.ENOENT)
|
|
return 0
|
|
}
|
|
|
|
panic(todo("", err))
|
|
}
|
|
|
|
if resolved_path == 0 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
if len(s) >= limits.PATH_MAX {
|
|
s = s[:limits.PATH_MAX-1]
|
|
}
|
|
|
|
copy((*RawMem)(unsafe.Pointer(resolved_path))[:len(s):len(s)], s)
|
|
(*RawMem)(unsafe.Pointer(resolved_path))[len(s)] = 0
|
|
return resolved_path
|
|
}
|
|
|
|
// struct tm *gmtime_r(const time_t *timep, struct tm *result);
|
|
func Xgmtime_r(t *TLS, timep, result uintptr) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// // char *inet_ntoa(struct in_addr in);
|
|
// func Xinet_ntoa(t *TLS, in1 in.In_addr) uintptr {
|
|
// panic(todo(""))
|
|
// }
|
|
|
|
// func X__ccgo_in6addr_anyp(t *TLS) uintptr {
|
|
// return uintptr(unsafe.Pointer(&in6_addr_any))
|
|
// }
|
|
|
|
func Xabort(t *TLS) {
|
|
panic(todo(""))
|
|
// if dmesgs {
|
|
// dmesg("%v:\n%s", origin(1), debug.Stack())
|
|
// }
|
|
// p := Xmalloc(t, types.Size_t(unsafe.Sizeof(signal.Sigaction{})))
|
|
// if p == 0 {
|
|
// panic("OOM")
|
|
// }
|
|
//
|
|
// *(*signal.Sigaction)(unsafe.Pointer(p)) = signal.Sigaction{
|
|
// F__sigaction_handler: struct{ Fsa_handler signal.X__sighandler_t }{Fsa_handler: signal.SIG_DFL},
|
|
// }
|
|
// Xsigaction(t, signal.SIGABRT, p, 0)
|
|
// Xfree(t, p)
|
|
// unix.Kill(unix.Getpid(), syscall.Signal(signal.SIGABRT))
|
|
// panic(todo("unrechable"))
|
|
}
|
|
|
|
// int fflush(FILE *stream);
|
|
func Xfflush(t *TLS, stream uintptr) int32 {
|
|
f, ok := winGetObject(stream).(*file)
|
|
if !ok {
|
|
t.setErrno(errno.EBADF)
|
|
return -1
|
|
}
|
|
err := syscall.FlushFileBuffers(f.Handle)
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
return -1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
|
|
func Xfread(t *TLS, ptr uintptr, size, nmemb types.Size_t, stream uintptr) types.Size_t {
|
|
f, ok := winGetObject(stream).(*file)
|
|
if !ok {
|
|
t.setErrno(errno.EBADF)
|
|
return 0
|
|
}
|
|
|
|
var sz = size * nmemb
|
|
var obuf = ((*RawMem)(unsafe.Pointer(ptr)))[:sz]
|
|
n, err := syscall.Read(f.Handle, obuf)
|
|
if err != nil {
|
|
f.setErr()
|
|
return 0
|
|
}
|
|
|
|
if dmesgs {
|
|
// dmesg("%v: %d %#x x %#x: %#x\n%s", origin(1), file(stream).fd(), size, nmemb, types.Size_t(m)/size, hex.Dump(GoBytes(ptr, int(m))))
|
|
dmesg("%v: %d %#x x %#x: %#x\n%s", origin(1), f._fd, size, nmemb, types.Size_t(n)/size)
|
|
}
|
|
|
|
return types.Size_t(n) / size
|
|
|
|
}
|
|
|
|
// size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
|
|
func Xfwrite(t *TLS, ptr uintptr, size, nmemb types.Size_t, stream uintptr) types.Size_t {
|
|
if ptr == 0 || size == 0 {
|
|
return 0
|
|
}
|
|
|
|
f, ok := winGetObject(stream).(*file)
|
|
if !ok {
|
|
t.setErrno(errno.EBADF)
|
|
return 0
|
|
}
|
|
|
|
var sz = size * nmemb
|
|
var obuf = ((*RawMem)(unsafe.Pointer(ptr)))[:sz]
|
|
n, err := syscall.Write(f.Handle, obuf)
|
|
if err != nil {
|
|
f.setErr()
|
|
return 0
|
|
}
|
|
|
|
if dmesgs {
|
|
// // dmesg("%v: %d %#x x %#x: %#x\n%s", origin(1), file(stream).fd(), size, nmemb, types.Size_t(m)/size, hex.Dump(GoBytes(ptr, int(m))))
|
|
dmesg("%v: %d %#x x %#x: %#x\n%s", origin(1), f._fd, size, nmemb, types.Size_t(n)/size)
|
|
}
|
|
return types.Size_t(n) / size
|
|
}
|
|
|
|
// int fclose(FILE *stream);
|
|
func Xfclose(t *TLS, stream uintptr) int32 {
|
|
f, ok := winGetObject(stream).(*file)
|
|
if !ok {
|
|
t.setErrno(errno.EBADF)
|
|
return -1
|
|
}
|
|
return f.close(t)
|
|
}
|
|
|
|
// int fputc(int c, FILE *stream);
|
|
func Xfputc(t *TLS, c int32, stream uintptr) int32 {
|
|
f, ok := winGetObject(stream).(*file)
|
|
if !ok {
|
|
t.setErrno(errno.EBADF)
|
|
return -1
|
|
}
|
|
if _, err := fwrite(f._fd, []byte{byte(c)}); err != nil {
|
|
return -1
|
|
}
|
|
return int32(byte(c))
|
|
}
|
|
|
|
// int fseek(FILE *stream, long offset, int whence);
|
|
func Xfseek(t *TLS, stream uintptr, offset long, whence int32) int32 {
|
|
f, ok := winGetObject(stream).(*file)
|
|
if !ok {
|
|
t.setErrno(errno.EBADF)
|
|
return -1
|
|
}
|
|
if n := Xlseek(t, f._fd, types.Off_t(offset), whence); n < 0 {
|
|
if dmesgs {
|
|
dmesg("%v: fd %v, off %#x, whence %v: %v", origin(1), f._fd, offset, whenceStr(whence), n)
|
|
}
|
|
f.setErr()
|
|
return -1
|
|
}
|
|
|
|
if dmesgs {
|
|
dmesg("%v: fd %v, off %#x, whence %v: ok", origin(1), f._fd, offset, whenceStr(whence))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// long ftell(FILE *stream);
|
|
func Xftell(t *TLS, stream uintptr) long {
|
|
f, ok := winGetObject(stream).(*file)
|
|
if !ok {
|
|
t.setErrno(errno.EBADF)
|
|
return -1
|
|
}
|
|
|
|
n := Xlseek(t, f._fd, 0, syscall.FILE_CURRENT)
|
|
if n < 0 {
|
|
f.setErr()
|
|
return -1
|
|
}
|
|
|
|
if dmesgs {
|
|
dmesg("%v: fd %v, n %#x: ok %#x", origin(1), f._fd, n, long(n))
|
|
}
|
|
return long(n)
|
|
}
|
|
|
|
// int ferror(FILE *stream);
|
|
func Xferror(t *TLS, stream uintptr) int32 {
|
|
f, ok := winGetObject(stream).(*file)
|
|
if !ok {
|
|
t.setErrno(errno.EBADF)
|
|
return -1
|
|
}
|
|
|
|
return Bool32(f.err())
|
|
}
|
|
|
|
// int getc(FILE *stream);
|
|
func Xfgetc(t *TLS, stream uintptr) int32 {
|
|
f, ok := winGetObject(stream).(*file)
|
|
if !ok {
|
|
t.setErrno(errno.EBADF)
|
|
return stdio.EOF
|
|
}
|
|
|
|
var buf [1]byte
|
|
if n, _ := syscall.Read(f.Handle, buf[:]); n != 0 {
|
|
return int32(buf[0])
|
|
}
|
|
|
|
return stdio.EOF
|
|
}
|
|
|
|
// int ungetc(int c, FILE *stream);
|
|
func Xungetc(t *TLS, c int32, stream uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int fscanf(FILE *stream, const char *format, ...);
|
|
func Xfscanf(t *TLS, stream, format, va uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int fputs(const char *s, FILE *stream);
|
|
func Xfputs(t *TLS, s, stream uintptr) int32 {
|
|
f, ok := winGetObject(stream).(*file)
|
|
if !ok {
|
|
t.setErrno(errno.EBADF)
|
|
return -1
|
|
}
|
|
gS := GoString(s)
|
|
if _, err := fwrite(f._fd, []byte(gS)); err != nil {
|
|
return -1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// var getservbynameStaticResult netdb.Servent
|
|
//
|
|
// // struct servent *getservbyname(const char *name, const char *proto);
|
|
// func Xgetservbyname(t *TLS, name, proto uintptr) uintptr {
|
|
// var protoent *gonetdb.Protoent
|
|
// if proto != 0 {
|
|
// protoent = gonetdb.GetProtoByName(GoString(proto))
|
|
// }
|
|
// servent := gonetdb.GetServByName(GoString(name), protoent)
|
|
// if servent == nil {
|
|
// if dmesgs {
|
|
// dmesg("%q %q: nil (protoent %+v)", GoString(name), GoString(proto), protoent)
|
|
// }
|
|
// return 0
|
|
// }
|
|
//
|
|
// Xfree(t, (*netdb.Servent)(unsafe.Pointer(&getservbynameStaticResult)).Fs_name)
|
|
// if v := (*netdb.Servent)(unsafe.Pointer(&getservbynameStaticResult)).Fs_aliases; v != 0 {
|
|
// for {
|
|
// p := *(*uintptr)(unsafe.Pointer(v))
|
|
// if p == 0 {
|
|
// break
|
|
// }
|
|
//
|
|
// Xfree(t, p)
|
|
// v += unsafe.Sizeof(uintptr(0))
|
|
// }
|
|
// Xfree(t, v)
|
|
// }
|
|
// Xfree(t, (*netdb.Servent)(unsafe.Pointer(&getservbynameStaticResult)).Fs_proto)
|
|
// cname, err := CString(servent.Name)
|
|
// if err != nil {
|
|
// getservbynameStaticResult = netdb.Servent{}
|
|
// return 0
|
|
// }
|
|
//
|
|
// var protoname uintptr
|
|
// if protoent != nil {
|
|
// if protoname, err = CString(protoent.Name); err != nil {
|
|
// Xfree(t, cname)
|
|
// getservbynameStaticResult = netdb.Servent{}
|
|
// return 0
|
|
// }
|
|
// }
|
|
// var a []uintptr
|
|
// for _, v := range servent.Aliases {
|
|
// cs, err := CString(v)
|
|
// if err != nil {
|
|
// for _, v := range a {
|
|
// Xfree(t, v)
|
|
// }
|
|
// return 0
|
|
// }
|
|
//
|
|
// a = append(a, cs)
|
|
// }
|
|
// v := Xcalloc(t, types.Size_t(len(a)+1), types.Size_t(unsafe.Sizeof(uintptr(0))))
|
|
// if v == 0 {
|
|
// Xfree(t, cname)
|
|
// Xfree(t, protoname)
|
|
// for _, v := range a {
|
|
// Xfree(t, v)
|
|
// }
|
|
// getservbynameStaticResult = netdb.Servent{}
|
|
// return 0
|
|
// }
|
|
// for _, p := range a {
|
|
// *(*uintptr)(unsafe.Pointer(v)) = p
|
|
// v += unsafe.Sizeof(uintptr(0))
|
|
// }
|
|
//
|
|
// getservbynameStaticResult = netdb.Servent{
|
|
// Fs_name: cname,
|
|
// Fs_aliases: v,
|
|
// Fs_port: int32(servent.Port),
|
|
// Fs_proto: protoname,
|
|
// }
|
|
// return uintptr(unsafe.Pointer(&getservbynameStaticResult))
|
|
// }
|
|
|
|
// func Xreaddir64(t *TLS, dir uintptr) uintptr {
|
|
// return Xreaddir(t, dir)
|
|
// }
|
|
|
|
// func fcntlCmdStr(cmd int32) string {
|
|
// switch cmd {
|
|
// case fcntl.F_GETOWN:
|
|
// return "F_GETOWN"
|
|
// case fcntl.F_SETLK:
|
|
// return "F_SETLK"
|
|
// case fcntl.F_GETLK:
|
|
// return "F_GETLK"
|
|
// case fcntl.F_SETFD:
|
|
// return "F_SETFD"
|
|
// case fcntl.F_GETFD:
|
|
// return "F_GETFD"
|
|
// default:
|
|
// return fmt.Sprintf("cmd(%d)", cmd)
|
|
// }
|
|
// }
|
|
|
|
// _CRTIMP extern int *__cdecl _errno(void); // /usr/share/mingw-w64/include/errno.h:17:
|
|
func X_errno(t *TLS) uintptr {
|
|
return t.errnop
|
|
}
|
|
|
|
// int vfscanf(FILE * restrict stream, const char * restrict format, va_list arg);
|
|
func X__ms_vfscanf(t *TLS, stream, format, ap uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int vsscanf(const char *str, const char *format, va_list ap);
|
|
func X__ms_vsscanf(t *TLS, str, format, ap uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int vscanf(const char *format, va_list ap);
|
|
func X__ms_vscanf(t *TLS, format, ap uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int vsnprintf(char *str, size_t size, const char *format, va_list ap);
|
|
func X__ms_vsnprintf(t *TLS, str uintptr, size types.Size_t, format, ap uintptr) int32 {
|
|
return Xvsnprintf(t, str, size, format, ap)
|
|
}
|
|
|
|
// int vfwscanf(FILE *stream, const wchar_t *format, va_list argptr;);
|
|
func X__ms_vfwscanf(t *TLS, stream uintptr, format, ap uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int vwscanf(const wchar_t * restrict format, va_list arg);
|
|
func X__ms_vwscanf(t *TLS, format, ap uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int _vsnwprintf(wchar_t *buffer, size_t count, const wchar_t *format, va_list argptr);
|
|
func X_vsnwprintf(t *TLS, buffer uintptr, count types.Size_t, format, ap uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int vswscanf(const wchar_t *buffer, const wchar_t *format, va_list arglist);
|
|
func X__ms_vswscanf(t *TLS, stream uintptr, format, ap uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// __acrt_iob_func
|
|
func X__acrt_iob_func(t *TLS, fd uint32) uintptr {
|
|
|
|
f, ok := fdToFile(int32(fd))
|
|
if !ok {
|
|
t.setErrno(EBADF)
|
|
return 0
|
|
}
|
|
return f.t
|
|
}
|
|
|
|
// BOOL SetEvent(
|
|
//
|
|
// HANDLE hEvent
|
|
//
|
|
// );
|
|
func XSetEvent(t *TLS, hEvent uintptr) int32 {
|
|
r0, _, err := syscall.Syscall(procSetEvent.Addr(), 1, hEvent, 0, 0)
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// int _stricmp(
|
|
//
|
|
// const char *string1,
|
|
// const char *string2
|
|
//
|
|
// );
|
|
func X_stricmp(t *TLS, string1, string2 uintptr) int32 {
|
|
var s1 = strings.ToLower(GoString(string1))
|
|
var s2 = strings.ToLower(GoString(string2))
|
|
return int32(strings.Compare(s1, s2))
|
|
}
|
|
|
|
// BOOL HeapFree(
|
|
//
|
|
// HANDLE hHeap,
|
|
// DWORD dwFlags,
|
|
// _Frees_ptr_opt_ LPVOID lpMem
|
|
//
|
|
// );
|
|
func XHeapFree(t *TLS, hHeap uintptr, dwFlags uint32, lpMem uintptr) int32 {
|
|
r0, _, err := syscall.Syscall(procHeapFree.Addr(), 3, hHeap, uintptr(dwFlags), lpMem)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// HANDLE GetProcessHeap();
|
|
func XGetProcessHeap(t *TLS) uintptr {
|
|
r0, _, err := syscall.Syscall(procGetProcessHeap.Addr(), 0, 0, 0, 0)
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// LPVOID HeapAlloc(
|
|
//
|
|
// HANDLE hHeap,
|
|
// DWORD dwFlags,
|
|
// SIZE_T dwBytes
|
|
//
|
|
// );
|
|
func XHeapAlloc(t *TLS, hHeap uintptr, dwFlags uint32, dwBytes types.Size_t) uintptr {
|
|
r0, _, err := syscall.Syscall(procHeapAlloc.Addr(), 3, hHeap, uintptr(dwFlags), uintptr(dwBytes))
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// WCHAR * gai_strerrorW(
|
|
//
|
|
// int ecode
|
|
//
|
|
// );
|
|
func Xgai_strerrorW(t *TLS, _ ...interface{}) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// servent * getservbyname(
|
|
//
|
|
// const char *name,
|
|
// const char *proto
|
|
//
|
|
// );
|
|
func Xgetservbyname(t *TLS, _ ...interface{}) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// INT WSAAPI getaddrinfo(
|
|
//
|
|
// PCSTR pNodeName,
|
|
// PCSTR pServiceName,
|
|
// const ADDRINFOA *pHints,
|
|
// PADDRINFOA *ppResult
|
|
//
|
|
// );
|
|
func XWspiapiGetAddrInfo(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int wcscmp(
|
|
//
|
|
// const wchar_t *string1,
|
|
// const wchar_t *string2
|
|
//
|
|
// );
|
|
func Xwcscmp(t *TLS, string1, string2 uintptr) int32 {
|
|
var s1 = goWideString(string1)
|
|
var s2 = goWideString(string2)
|
|
return int32(strings.Compare(s1, s2))
|
|
}
|
|
|
|
// BOOL IsDebuggerPresent();
|
|
func XIsDebuggerPresent(t *TLS) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XExitProcess(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// BOOL GetVersionExW(
|
|
//
|
|
// LPOSVERSIONINFOW lpVersionInformation
|
|
//
|
|
// );
|
|
func XGetVersionExW(t *TLS, lpVersionInformation uintptr) int32 {
|
|
r0, _, err := syscall.Syscall(procGetVersionExW.Addr(), 1, lpVersionInformation, 0, 0)
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// BOOL GetVolumeNameForVolumeMountPointW(
|
|
//
|
|
// LPCWSTR lpszVolumeMountPoint,
|
|
// LPWSTR lpszVolumeName,
|
|
// DWORD cchBufferLength
|
|
//
|
|
// );
|
|
func XGetVolumeNameForVolumeMountPointW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// size_t wcslen(
|
|
//
|
|
// const wchar_t *str
|
|
//
|
|
// );
|
|
func Xwcslen(t *TLS, str uintptr) types.Size_t {
|
|
r0, _, _ := syscall.Syscall(procLstrlenW.Addr(), 1, str, 0, 0)
|
|
return types.Size_t(r0)
|
|
}
|
|
|
|
// HANDLE WINAPI GetStdHandle(
|
|
//
|
|
// _In_ DWORD nStdHandle
|
|
//
|
|
// );
|
|
func XGetStdHandle(t *TLS, nStdHandle uint32) uintptr {
|
|
h, err := syscall.GetStdHandle(int(nStdHandle))
|
|
if err != nil {
|
|
panic("no console")
|
|
}
|
|
return uintptr(h)
|
|
}
|
|
|
|
// BOOL CloseHandle(
|
|
//
|
|
// HANDLE hObject
|
|
//
|
|
// );
|
|
func XCloseHandle(t *TLS, hObject uintptr) int32 {
|
|
r := syscall.CloseHandle(syscall.Handle(hObject))
|
|
if r != nil {
|
|
return errno.EINVAL
|
|
}
|
|
return 1
|
|
}
|
|
|
|
// DWORD GetLastError();
|
|
func XGetLastError(t *TLS) uint32 {
|
|
var rv = *(*int32)(unsafe.Pointer(t.errnop))
|
|
return uint32(rv)
|
|
|
|
//r1, _, _ := syscall.Syscall(procGetLastError.Addr(), 0, 0, 0, 0)
|
|
//return uint32(r1)
|
|
}
|
|
|
|
// DWORD SetFilePointer(
|
|
//
|
|
// HANDLE hFile,
|
|
// LONG lDistanceToMove,
|
|
// PLONG lpDistanceToMoveHigh,
|
|
// DWORD dwMoveMethod
|
|
//
|
|
// );
|
|
func XSetFilePointer(t *TLS, hFile uintptr, lDistanceToMove long, lpDistanceToMoveHigh uintptr, dwMoveMethod uint32) uint32 {
|
|
r0, _, e1 := syscall.Syscall6(procSetFilePointer.Addr(), 4, hFile, uintptr(lDistanceToMove), lpDistanceToMoveHigh, uintptr(dwMoveMethod), 0, 0)
|
|
var uOff = uint32(r0)
|
|
if uOff == 0xffffffff {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
}
|
|
return uint32(r0)
|
|
}
|
|
|
|
// BOOL SetEndOfFile(
|
|
//
|
|
// HANDLE hFile
|
|
//
|
|
// );
|
|
func XSetEndOfFile(t *TLS, hFile uintptr) int32 {
|
|
err := syscall.SetEndOfFile(syscall.Handle(hFile))
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
return 0
|
|
}
|
|
return 1
|
|
}
|
|
|
|
// BOOL ReadFile(
|
|
//
|
|
// HANDLE hFile,
|
|
// LPVOID lpBuffer,
|
|
// DWORD nNumberOfBytesToRead,
|
|
// LPDWORD lpNumberOfBytesRead,
|
|
// LPOVERLAPPED lpOverlapped
|
|
//
|
|
// );
|
|
func XReadFile(t *TLS, hFile, lpBuffer uintptr, nNumberOfBytesToRead uint32, lpNumberOfBytesRead, lpOverlapped uintptr) int32 {
|
|
r1, _, e1 := syscall.Syscall6(procReadFile.Addr(), 5,
|
|
hFile, lpBuffer, uintptr(nNumberOfBytesToRead), uintptr(lpNumberOfBytesRead), uintptr(lpOverlapped), 0)
|
|
if r1 == 0 {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
return 0
|
|
}
|
|
return int32(r1)
|
|
}
|
|
|
|
// BOOL WriteFile(
|
|
//
|
|
// HANDLE hFile,
|
|
// LPCVOID lpBuffer,
|
|
// DWORD nNumberOfBytesToWrite,
|
|
// LPDWORD lpNumberOfBytesWritten,
|
|
// LPOVERLAPPED lpOverlapped
|
|
//
|
|
// );
|
|
func XWriteFile(t *TLS, hFile, lpBuffer uintptr, nNumberOfBytesToWrite uint32, lpNumberOfBytesWritten, lpOverlapped uintptr) int32 {
|
|
r1, _, e1 := syscall.Syscall6(procWriteFile.Addr(), 5,
|
|
hFile, lpBuffer, uintptr(nNumberOfBytesToWrite), lpNumberOfBytesWritten, lpOverlapped, 0)
|
|
if r1 == 0 {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
return 0
|
|
}
|
|
return int32(r1)
|
|
}
|
|
|
|
// DWORD GetFileAttributesW(
|
|
//
|
|
// LPCWSTR lpFileName
|
|
//
|
|
// );
|
|
func XGetFileAttributesW(t *TLS, lpFileName uintptr) uint32 {
|
|
attrs, err := syscall.GetFileAttributes((*uint16)(unsafe.Pointer(lpFileName)))
|
|
if attrs == syscall.INVALID_FILE_ATTRIBUTES {
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
}
|
|
return attrs
|
|
}
|
|
|
|
// HANDLE CreateFileW(
|
|
//
|
|
// LPCWSTR lpFileName,
|
|
// DWORD dwDesiredAccess,
|
|
// DWORD dwShareMode,
|
|
// LPSECURITY_ATTRIBUTES lpSecurityAttributes,
|
|
// DWORD dwCreationDisposition,
|
|
// DWORD dwFlagsAndAttributes,
|
|
// HANDLE hTemplateFile
|
|
//
|
|
// );
|
|
func XCreateFileW(t *TLS, lpFileName uintptr, dwDesiredAccess, dwShareMode uint32, lpSecurityAttributes uintptr, dwCreationDisposition, dwFlagsAndAttributes uint32, hTemplateFile uintptr) uintptr {
|
|
|
|
r0, _, e1 := syscall.Syscall9(procCreateFileW.Addr(), 7, lpFileName, uintptr(dwDesiredAccess), uintptr(dwShareMode), lpSecurityAttributes,
|
|
uintptr(dwCreationDisposition), uintptr(dwFlagsAndAttributes), hTemplateFile, 0, 0)
|
|
h := syscall.Handle(r0)
|
|
if h == syscall.InvalidHandle {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
return r0
|
|
}
|
|
return uintptr(h)
|
|
}
|
|
|
|
// BOOL DuplicateHandle(
|
|
//
|
|
// HANDLE hSourceProcessHandle,
|
|
// HANDLE hSourceHandle,
|
|
// HANDLE hTargetProcessHandle,
|
|
// LPHANDLE lpTargetHandle,
|
|
// DWORD dwDesiredAccess,
|
|
// BOOL bInheritHandle,
|
|
// DWORD dwOptions
|
|
//
|
|
// );
|
|
func XDuplicateHandle(t *TLS, hSourceProcessHandle, hSourceHandle, hTargetProcessHandle, lpTargetHandle uintptr, dwDesiredAccess uint32, bInheritHandle int32, dwOptions uint32) int32 {
|
|
r0, _, err := syscall.Syscall9(procDuplicateHandle.Addr(), 7, hSourceProcessHandle, hSourceHandle, hTargetProcessHandle,
|
|
lpTargetHandle, uintptr(dwDesiredAccess), uintptr(bInheritHandle), uintptr(dwOptions), 0, 0)
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// HANDLE GetCurrentProcess();
|
|
func XGetCurrentProcess(t *TLS) uintptr {
|
|
r0, _, e1 := syscall.Syscall(procGetCurrentProcess.Addr(), 0, 0, 0, 0)
|
|
if r0 == 0 {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// BOOL FlushFileBuffers(
|
|
//
|
|
// HANDLE hFile
|
|
//
|
|
// );
|
|
func XFlushFileBuffers(t *TLS, hFile uintptr) int32 {
|
|
err := syscall.FlushFileBuffers(syscall.Handle(hFile))
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
return -1
|
|
}
|
|
return 1
|
|
|
|
}
|
|
|
|
// DWORD GetFileType(
|
|
//
|
|
// HANDLE hFile
|
|
//
|
|
// );
|
|
func XGetFileType(t *TLS, hFile uintptr) uint32 {
|
|
n, err := syscall.GetFileType(syscall.Handle(hFile))
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
}
|
|
return n
|
|
}
|
|
|
|
// BOOL WINAPI GetConsoleMode(
|
|
//
|
|
// _In_ HANDLE hConsoleHandle,
|
|
// _Out_ LPDWORD lpMode
|
|
//
|
|
// );
|
|
func XGetConsoleMode(t *TLS, hConsoleHandle, lpMode uintptr) int32 {
|
|
err := syscall.GetConsoleMode(syscall.Handle(hConsoleHandle), (*uint32)(unsafe.Pointer(lpMode)))
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
return 0
|
|
}
|
|
return 1
|
|
}
|
|
|
|
// BOOL GetCommState(
|
|
//
|
|
// HANDLE hFile,
|
|
// LPDCB lpDCB
|
|
//
|
|
// );
|
|
func XGetCommState(t *TLS, hFile, lpDCB uintptr) int32 {
|
|
r1, _, err := syscall.Syscall(procGetCommState.Addr(), 2, hFile, lpDCB, 0)
|
|
if r1 == 0 {
|
|
t.setErrno(err)
|
|
return 0
|
|
}
|
|
return int32(r1)
|
|
}
|
|
|
|
// int _wcsnicmp(
|
|
//
|
|
// const wchar_t *string1,
|
|
// const wchar_t *string2,
|
|
// size_t count
|
|
//
|
|
// );
|
|
func X_wcsnicmp(t *TLS, string1, string2 uintptr, count types.Size_t) int32 {
|
|
|
|
var s1 = strings.ToLower(goWideString(string1))
|
|
var l1 = len(s1)
|
|
var s2 = strings.ToLower(goWideString(string2))
|
|
var l2 = len(s2)
|
|
|
|
// shorter is lesser
|
|
if l1 < l2 {
|
|
return -1
|
|
}
|
|
if l2 > l1 {
|
|
return 1
|
|
}
|
|
|
|
// compare at most count
|
|
var cmpLen = count
|
|
if types.Size_t(l1) < cmpLen {
|
|
cmpLen = types.Size_t(l1)
|
|
}
|
|
return int32(strings.Compare(s1[:cmpLen], s2[:cmpLen]))
|
|
}
|
|
|
|
// BOOL WINAPI ReadConsole(
|
|
//
|
|
// _In_ HANDLE hConsoleInput,
|
|
// _Out_ LPVOID lpBuffer,
|
|
// _In_ DWORD nNumberOfCharsToRead,
|
|
// _Out_ LPDWORD lpNumberOfCharsRead,
|
|
// _In_opt_ LPVOID pInputControl
|
|
//
|
|
// );
|
|
func XReadConsoleW(t *TLS, hConsoleInput, lpBuffer uintptr, nNumberOfCharsToRead uint32, lpNumberOfCharsRead, pInputControl uintptr) int32 {
|
|
|
|
rv, _, err := syscall.Syscall6(procReadConsoleW.Addr(), 5, hConsoleInput,
|
|
lpBuffer, uintptr(nNumberOfCharsToRead), lpNumberOfCharsRead, pInputControl, 0)
|
|
if rv == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
|
|
return int32(rv)
|
|
}
|
|
|
|
// BOOL WINAPI WriteConsoleW(
|
|
//
|
|
// _In_ HANDLE hConsoleOutput,
|
|
// _In_ const VOID *lpBuffer,
|
|
// _In_ DWORD nNumberOfCharsToWrite,
|
|
// _Out_opt_ LPDWORD lpNumberOfCharsWritten,
|
|
// _Reserved_ LPVOID lpReserved
|
|
//
|
|
// );
|
|
func XWriteConsoleW(t *TLS, hConsoleOutput, lpBuffer uintptr, nNumberOfCharsToWrite uint32, lpNumberOfCharsWritten, lpReserved uintptr) int32 {
|
|
rv, _, err := syscall.Syscall6(procWriteConsoleW.Addr(), 5, hConsoleOutput,
|
|
lpBuffer, uintptr(nNumberOfCharsToWrite), lpNumberOfCharsWritten, lpReserved, 0)
|
|
if rv == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(rv)
|
|
}
|
|
|
|
// DWORD WaitForSingleObject(
|
|
//
|
|
// HANDLE hHandle,
|
|
// DWORD dwMilliseconds
|
|
//
|
|
// );
|
|
func XWaitForSingleObject(t *TLS, hHandle uintptr, dwMilliseconds uint32) uint32 {
|
|
rv, err := syscall.WaitForSingleObject(syscall.Handle(hHandle), dwMilliseconds)
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
}
|
|
return rv
|
|
}
|
|
|
|
// BOOL ResetEvent(
|
|
//
|
|
// HANDLE hEvent
|
|
//
|
|
// );
|
|
func XResetEvent(t *TLS, hEvent uintptr) int32 {
|
|
rv, _, err := syscall.Syscall(procResetEvent.Addr(), 1, hEvent, 0, 0)
|
|
if rv == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(rv)
|
|
}
|
|
|
|
// BOOL WINAPI PeekConsoleInput(
|
|
//
|
|
// _In_ HANDLE hConsoleInput,
|
|
// _Out_ PINPUT_RECORD lpBuffer,
|
|
// _In_ DWORD nLength,
|
|
// _Out_ LPDWORD lpNumberOfEventsRead
|
|
//
|
|
// );
|
|
func XPeekConsoleInputW(t *TLS, hConsoleInput, lpBuffer uintptr, nLength uint32, lpNumberOfEventsRead uintptr) int32 {
|
|
r0, _, err := syscall.Syscall6(procPeekConsoleInputW.Addr(), 4, hConsoleInput, lpBuffer, uintptr(nLength), lpNumberOfEventsRead, 0, 0)
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// int WINAPIV wsprintfA(
|
|
//
|
|
// LPSTR ,
|
|
// LPCSTR ,
|
|
// ...
|
|
//
|
|
// );
|
|
func XwsprintfA(t *TLS, buf, format, args uintptr) int32 {
|
|
return Xsprintf(t, buf, format, args)
|
|
}
|
|
|
|
// UINT WINAPI GetConsoleCP(void);
|
|
func XGetConsoleCP(t *TLS) uint32 {
|
|
r0, _, err := syscall.Syscall(procGetConsoleCP.Addr(), 0, 0, 0, 0)
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return uint32(r0)
|
|
}
|
|
|
|
// UINT WINAPI SetConsoleCP(UNIT);
|
|
//func setConsoleCP(cp uint32) uint32 {
|
|
//
|
|
// r0, _, _ := syscall.Syscall(procSetConsoleCP.Addr(), 1, uintptr(cp), 0, 0)
|
|
// if r0 == 0 {
|
|
// panic("setcp failed")
|
|
// }
|
|
// return uint32(r0)
|
|
//}
|
|
|
|
// HANDLE CreateEventW(
|
|
//
|
|
// LPSECURITY_ATTRIBUTES lpEventAttributes,
|
|
// BOOL bManualReset,
|
|
// BOOL bInitialState,
|
|
// LPCWSTR lpName
|
|
//
|
|
// );
|
|
func XCreateEventW(t *TLS, lpEventAttributes uintptr, bManualReset, bInitialState int32, lpName uintptr) uintptr {
|
|
r0, _, err := syscall.Syscall6(procCreateEventW.Addr(), 4, lpEventAttributes, uintptr(bManualReset),
|
|
uintptr(bInitialState), lpName, 0, 0)
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
type ThreadAdapter struct {
|
|
token uintptr
|
|
tls *TLS
|
|
param uintptr
|
|
threadFunc func(*TLS, uintptr) uint32
|
|
}
|
|
|
|
func (ta *ThreadAdapter) run() uintptr {
|
|
r := ta.threadFunc(ta.tls, ta.param)
|
|
ta.tls.Close()
|
|
removeObject(ta.token)
|
|
return uintptr(r)
|
|
}
|
|
|
|
func ThreadProc(p uintptr) uintptr {
|
|
adp, ok := winGetObject(p).(*ThreadAdapter)
|
|
if !ok {
|
|
panic("invalid thread")
|
|
}
|
|
return adp.run()
|
|
}
|
|
|
|
// HANDLE CreateThread(
|
|
//
|
|
// LPSECURITY_ATTRIBUTES lpThreadAttributes,
|
|
// SIZE_T dwStackSize,
|
|
// LPTHREAD_START_ROUTINE lpStartAddress,
|
|
// __drv_aliasesMem LPVOID lpParameter,
|
|
// DWORD dwCreationFlags,
|
|
// LPDWORD lpThreadId
|
|
//
|
|
// );
|
|
func XCreateThread(t *TLS, lpThreadAttributes uintptr, dwStackSize types.Size_t, lpStartAddress, lpParameter uintptr, dwCreationFlags uint32, lpThreadId uintptr) uintptr {
|
|
f := (*struct{ f func(*TLS, uintptr) uint32 })(unsafe.Pointer(&struct{ uintptr }{lpStartAddress})).f
|
|
var tAdp = ThreadAdapter{threadFunc: f, tls: NewTLS(), param: lpParameter}
|
|
tAdp.token = addObject(&tAdp)
|
|
|
|
r0, _, err := syscall.Syscall6(procCreateThread.Addr(), 6, lpThreadAttributes, uintptr(dwStackSize),
|
|
threadCallback, tAdp.token, uintptr(dwCreationFlags), lpThreadId)
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// BOOL SetThreadPriority(
|
|
//
|
|
// HANDLE hThread,
|
|
// int nPriority
|
|
//
|
|
// );
|
|
func XSetThreadPriority(t *TLS, hThread uintptr, nPriority int32) int32 {
|
|
|
|
//r0, _, err := syscall.Syscall(procSetThreadPriority.Addr(), 2, hThread, uintptr(nPriority), 0)
|
|
//if r0 == 0 {
|
|
// t.setErrno(err)
|
|
//}
|
|
//return int32(r0)
|
|
return 1
|
|
}
|
|
|
|
// BOOL WINAPI SetConsoleMode(
|
|
//
|
|
// _In_ HANDLE hConsoleHandle,
|
|
// _In_ DWORD dwMode
|
|
//
|
|
// );
|
|
func XSetConsoleMode(t *TLS, hConsoleHandle uintptr, dwMode uint32) int32 {
|
|
rv, _, err := syscall.Syscall(procSetConsoleMode.Addr(), 2, hConsoleHandle, uintptr(dwMode), 0)
|
|
if rv == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(rv)
|
|
}
|
|
|
|
func XPurgeComm(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XClearCommError(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// void DeleteCriticalSection(
|
|
//
|
|
// LPCRITICAL_SECTION lpCriticalSection
|
|
//
|
|
// );
|
|
func XDeleteCriticalSection(t *TLS, lpCriticalSection uintptr) {
|
|
syscall.Syscall(procDeleteCriticalSection.Addr(), 1, lpCriticalSection, 0, 0)
|
|
}
|
|
|
|
// void EnterCriticalSection(
|
|
//
|
|
// LPCRITICAL_SECTION lpCriticalSection
|
|
//
|
|
// );
|
|
func XEnterCriticalSection(t *TLS, lpCriticalSection uintptr) {
|
|
syscall.Syscall(procEnterCriticalSection.Addr(), 1, lpCriticalSection, 0, 0)
|
|
}
|
|
|
|
// void LeaveCriticalSection(
|
|
//
|
|
// LPCRITICAL_SECTION lpCriticalSection
|
|
//
|
|
// );
|
|
func XLeaveCriticalSection(t *TLS, lpCriticalSection uintptr) {
|
|
syscall.Syscall(procLeaveCriticalSection.Addr(), 1, lpCriticalSection, 0, 0)
|
|
}
|
|
|
|
func XGetOverlappedResult(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XSetupComm(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XSetCommTimeouts(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// void InitializeCriticalSection(
|
|
//
|
|
// LPCRITICAL_SECTION lpCriticalSection
|
|
//
|
|
// );
|
|
func XInitializeCriticalSection(t *TLS, lpCriticalSection uintptr) {
|
|
// InitializeCriticalSection always succeeds, even in low memory situations.
|
|
syscall.Syscall(procInitializeCriticalSection.Addr(), 1, lpCriticalSection, 0, 0)
|
|
}
|
|
|
|
func XBuildCommDCBW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XSetCommState(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func X_strnicmp(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XEscapeCommFunction(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XGetCommModemStatus(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// BOOL MoveFileW(
|
|
//
|
|
// LPCWSTR lpExistingFileName,
|
|
// LPCWSTR lpNewFileName
|
|
//
|
|
// );
|
|
func XMoveFileW(t *TLS, lpExistingFileName, lpNewFileName uintptr) int32 {
|
|
r0, _, err := syscall.Syscall(procMoveFileW.Addr(), 2, lpExistingFileName, lpNewFileName, 0)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// DWORD GetFullPathNameW(
|
|
//
|
|
// LPCWSTR lpFileName,
|
|
// DWORD nBufferLength,
|
|
// LPWSTR lpBuffer,
|
|
// LPWSTR *lpFilePart
|
|
//
|
|
// );
|
|
func XGetFullPathNameW(t *TLS, lpFileName uintptr, nBufferLength uint32, lpBuffer, lpFilePart uintptr) uint32 {
|
|
r0, _, e1 := syscall.Syscall6(procGetFullPathNameW.Addr(), 4, lpFileName, uintptr(nBufferLength), uintptr(lpBuffer), uintptr(lpFilePart), 0, 0)
|
|
n := uint32(r0)
|
|
if n == 0 {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
// LPWSTR CharLowerW(
|
|
//
|
|
// LPWSTR lpsz
|
|
//
|
|
// );
|
|
func XCharLowerW(t *TLS, lpsz uintptr) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// BOOL CreateDirectoryW(
|
|
//
|
|
// LPCWSTR lpPathName,
|
|
// LPSECURITY_ATTRIBUTES lpSecurityAttributes
|
|
//
|
|
// );
|
|
func XCreateDirectoryW(t *TLS, lpPathName, lpSecurityAttributes uintptr) int32 {
|
|
err := syscall.CreateDirectory((*uint16)(unsafe.Pointer(lpPathName)),
|
|
(*syscall.SecurityAttributes)(unsafe.Pointer(lpSecurityAttributes)))
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
return 0
|
|
}
|
|
return 1
|
|
}
|
|
|
|
// BOOL SetFileAttributesW(
|
|
//
|
|
// LPCWSTR lpFileName,
|
|
// DWORD dwFileAttributes
|
|
//
|
|
// );
|
|
func XSetFileAttributesW(t *TLS, lpFileName uintptr, dwFileAttributes uint32) int32 {
|
|
err := syscall.SetFileAttributes((*uint16)(unsafe.Pointer(lpFileName)), dwFileAttributes)
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
return 0
|
|
}
|
|
return 1
|
|
}
|
|
|
|
// UINT GetTempFileNameW(
|
|
//
|
|
// LPCWSTR lpPathName,
|
|
// LPCWSTR lpPrefixString,
|
|
// UINT uUnique,
|
|
// LPWSTR lpTempFileName
|
|
//
|
|
// );
|
|
func XGetTempFileNameW(t *TLS, lpPathName, lpPrefixString uintptr, uUnique uint32, lpTempFileName uintptr) uint32 {
|
|
r0, _, e1 := syscall.Syscall6(procGetTempFileNameW.Addr(), 4, lpPathName, lpPrefixString, uintptr(uUnique), lpTempFileName, 0, 0)
|
|
if r0 == 0 {
|
|
t.setErrno(e1)
|
|
}
|
|
return uint32(r0)
|
|
}
|
|
|
|
// BOOL CopyFileW(
|
|
//
|
|
// LPCWSTR lpExistingFileName,
|
|
// LPCWSTR lpNewFileName,
|
|
// BOOL bFailIfExists
|
|
//
|
|
// );
|
|
func XCopyFileW(t *TLS, lpExistingFileName, lpNewFileName uintptr, bFailIfExists int32) int32 {
|
|
r0, _, e1 := syscall.Syscall(procCopyFileW.Addr(), 3, lpExistingFileName, lpNewFileName, uintptr(bFailIfExists))
|
|
if r0 == 0 {
|
|
t.setErrno(e1)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// BOOL DeleteFileW(
|
|
//
|
|
// LPCWSTR lpFileName
|
|
//
|
|
// );
|
|
func XDeleteFileW(t *TLS, lpFileName uintptr) int32 {
|
|
err := syscall.DeleteFile((*uint16)(unsafe.Pointer(lpFileName)))
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
return 0
|
|
}
|
|
return 1
|
|
}
|
|
|
|
// BOOL RemoveDirectoryW(
|
|
//
|
|
// LPCWSTR lpPathName
|
|
//
|
|
// );
|
|
func XRemoveDirectoryW(t *TLS, lpPathName uintptr) int32 {
|
|
err := syscall.RemoveDirectory((*uint16)(unsafe.Pointer(lpPathName)))
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
return 0
|
|
}
|
|
return 1
|
|
}
|
|
|
|
// HANDLE FindFirstFileW(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFindFileData);
|
|
func XFindFirstFileW(t *TLS, lpFileName, lpFindFileData uintptr) uintptr {
|
|
r0, _, e1 := syscall.Syscall(procFindFirstFileW.Addr(), 2, lpFileName, lpFindFileData, 0)
|
|
handle := syscall.Handle(r0)
|
|
if handle == syscall.InvalidHandle {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// HANDLE FindFirstFileExW(
|
|
//
|
|
// LPCWSTR lpFileName,
|
|
// FINDEX_INFO_LEVELS fInfoLevelId,
|
|
// LPVOID lpFindFileData,
|
|
// FINDEX_SEARCH_OPS fSearchOp,
|
|
// LPVOID lpSearchFilter,
|
|
// DWORD dwAdditionalFlags
|
|
//
|
|
// );
|
|
func XFindFirstFileExW(t *TLS, lpFileName uintptr, fInfoLevelId int32, lpFindFileData uintptr, fSearchOp int32, lpSearchFilter uintptr, dwAdditionalFlags uint32) uintptr {
|
|
r0, _, e1 := syscall.Syscall6(procFindFirstFileExW.Addr(), 6, lpFileName, uintptr(fInfoLevelId), lpFindFileData, uintptr(fSearchOp), lpSearchFilter, uintptr(dwAdditionalFlags))
|
|
handle := syscall.Handle(r0)
|
|
if handle == syscall.InvalidHandle {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// BOOL FindClose(HANDLE hFindFile);
|
|
func XFindClose(t *TLS, hFindFile uintptr) int32 {
|
|
r0, _, e1 := syscall.Syscall(procFindClose.Addr(), 1, hFindFile, 0, 0)
|
|
if r0 == 0 {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// BOOL FindNextFileW(
|
|
//
|
|
// HANDLE hFindFile,
|
|
// LPWIN32_FIND_DATAW lpFindFileData
|
|
//
|
|
// );
|
|
func XFindNextFileW(t *TLS, hFindFile, lpFindFileData uintptr) int32 {
|
|
r0, _, e1 := syscall.Syscall(procFindNextFileW.Addr(), 2, hFindFile, lpFindFileData, 0)
|
|
if r0 == 0 {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// DWORD GetLogicalDriveStringsA(
|
|
//
|
|
// DWORD nBufferLength,
|
|
// LPSTR lpBuffer
|
|
//
|
|
// );
|
|
func XGetLogicalDriveStringsA(t *TLS, nBufferLength uint32, lpBuffer uintptr) uint32 {
|
|
r0, _, err := syscall.Syscall(procGetLogicalDriveStringsA.Addr(), 2, uintptr(nBufferLength), lpBuffer, 0)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return uint32(r0)
|
|
}
|
|
|
|
// BOOL GetVolumeInformationA(
|
|
//
|
|
// LPCSTR lpRootPathName,
|
|
// LPSTR lpVolumeNameBuffer,
|
|
// DWORD nVolumeNameSize,
|
|
// LPDWORD lpVolumeSerialNumber,
|
|
// LPDWORD lpMaximumComponentLength,
|
|
// LPDWORD lpFileSystemFlags,
|
|
// LPSTR lpFileSystemNameBuffer,
|
|
// DWORD nFileSystemNameSize
|
|
//
|
|
// );
|
|
func XGetVolumeInformationA(t *TLS, lpRootPathName, lpVolumeNameBuffer uintptr, nVolumeNameSize uint32, lpVolumeSerialNumber, lpMaximumComponentLength, lpFileSystemFlags, lpFileSystemNameBuffer uintptr, nFileSystemNameSize uint32) int32 {
|
|
r0, _, err := syscall.Syscall9(procGetVolumeInformationA.Addr(), 8,
|
|
lpRootPathName,
|
|
lpVolumeNameBuffer,
|
|
uintptr(nVolumeNameSize),
|
|
lpVolumeSerialNumber,
|
|
lpMaximumComponentLength,
|
|
lpFileSystemFlags,
|
|
lpFileSystemNameBuffer,
|
|
uintptr(nFileSystemNameSize),
|
|
0,
|
|
)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// BOOL CreateHardLinkW(
|
|
//
|
|
// LPCWSTR lpFileName,
|
|
// LPCWSTR lpExistingFileName,
|
|
// LPSECURITY_ATTRIBUTES lpSecurityAttributes
|
|
//
|
|
// );
|
|
func XCreateHardLinkW(t *TLS, lpFileName, lpExistingFileName, lpSecurityAttributes uintptr) int32 {
|
|
r0, _, err := syscall.Syscall(procCreateHardLinkW.Addr(), 1, lpFileName, lpExistingFileName, lpSecurityAttributes)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// BOOL DeviceIoControl(
|
|
//
|
|
// HANDLE hDevice,
|
|
// DWORD dwIoControlCode,
|
|
// LPVOID lpInBuffer,
|
|
// DWORD nInBufferSize,
|
|
// LPVOID lpOutBuffer,
|
|
// DWORD nOutBufferSize,
|
|
// LPDWORD lpBytesReturned,
|
|
// LPOVERLAPPED lpOverlapped
|
|
//
|
|
// );
|
|
func XDeviceIoControl(t *TLS, hDevice uintptr, dwIoControlCode uint32, lpInBuffer uintptr, nInBufferSize uint32, lpOutBuffer uintptr, nOutBufferSize uint32, lpBytesReturned, lpOverlapped uintptr) int32 {
|
|
r0, _, err := syscall.Syscall9(procDeviceIoControl.Addr(), 8, hDevice, uintptr(dwIoControlCode), lpInBuffer,
|
|
uintptr(nInBufferSize), lpOutBuffer, uintptr(nOutBufferSize), lpBytesReturned, lpOverlapped, 0)
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// int wcsncmp(
|
|
//
|
|
// const wchar_t *string1,
|
|
// const wchar_t *string2,
|
|
// size_t count
|
|
//
|
|
// );
|
|
func Xwcsncmp(t *TLS, string1, string2 uintptr, count types.Size_t) int32 {
|
|
var s1 = goWideString(string1)
|
|
var l1 = len(s1)
|
|
var s2 = goWideString(string2)
|
|
var l2 = len(s2)
|
|
|
|
// shorter is lesser
|
|
if l1 < l2 {
|
|
return -1
|
|
}
|
|
if l2 > l1 {
|
|
return 1
|
|
}
|
|
|
|
// compare at most count
|
|
var cmpLen = count
|
|
if types.Size_t(l1) < cmpLen {
|
|
cmpLen = types.Size_t(l1)
|
|
}
|
|
return int32(strings.Compare(s1[:cmpLen], s2[:cmpLen]))
|
|
}
|
|
|
|
// int MultiByteToWideChar(
|
|
//
|
|
// UINT CodePage,
|
|
// DWORD dwFlags,
|
|
// _In_NLS_string_(cbMultiByte)LPCCH lpMultiByteStr,
|
|
// int cbMultiByte,
|
|
// LPWSTR lpWideCharStr,
|
|
// int cchWideChar
|
|
//
|
|
// );
|
|
func XMultiByteToWideChar(t *TLS, CodePage uint32, dwFlags uint32, lpMultiByteStr uintptr, cbMultiByte int32, lpWideCharStr uintptr, cchWideChar int32) int32 {
|
|
r1, _, _ := syscall.Syscall6(procMultiByteToWideChar.Addr(), 6,
|
|
uintptr(CodePage), uintptr(dwFlags), uintptr(lpMultiByteStr),
|
|
uintptr(cbMultiByte), uintptr(lpWideCharStr), uintptr(cchWideChar))
|
|
return (int32(r1))
|
|
}
|
|
|
|
// void OutputDebugStringW(
|
|
//
|
|
// LPCWSTR lpOutputString
|
|
//
|
|
// );
|
|
func XOutputDebugStringW(t *TLS, lpOutputString uintptr) {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XMessageBeep(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
//====
|
|
|
|
// long _InterlockedCompareExchange(
|
|
//
|
|
// long volatile * Destination,
|
|
// long Exchange,
|
|
// long Comparand
|
|
//
|
|
// );
|
|
func X_InterlockedCompareExchange(t *TLS, Destination uintptr, Exchange, Comparand long) long {
|
|
|
|
// The function returns the initial value of the Destination parameter.
|
|
var v = *(*int32)(unsafe.Pointer(Destination))
|
|
_ = atomic.CompareAndSwapInt32((*int32)(unsafe.Pointer(Destination)), Comparand, Exchange)
|
|
return long(v)
|
|
}
|
|
|
|
// int rename(const char *oldpath, const char *newpath);
|
|
func Xrename(t *TLS, oldpath, newpath uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// BOOL AreFileApisANSI();
|
|
func XAreFileApisANSI(t *TLS) int32 {
|
|
|
|
r0, _, _ := syscall.Syscall(procAreFileApisANSI.Addr(), 0, 0, 0, 0)
|
|
return int32(r0)
|
|
}
|
|
|
|
// HANDLE CreateFileA(
|
|
//
|
|
// LPCSTR lpFileName,
|
|
// DWORD dwDesiredAccess,
|
|
// DWORD dwShareMode,
|
|
// LPSECURITY_ATTRIBUTES lpSecurityAttributes,
|
|
// DWORD dwCreationDisposition,
|
|
// DWORD dwFlagsAndAttributes,
|
|
// HANDLE hTemplateFile
|
|
//
|
|
// );
|
|
func XCreateFileA(t *TLS, lpFileName uintptr, dwDesiredAccess, dwShareMode uint32,
|
|
lpSecurityAttributes uintptr, dwCreationDisposition, dwFlagsAndAttributes uint32, hTemplateFile uintptr) uintptr {
|
|
|
|
r0, _, e1 := syscall.Syscall9(procCreateFileA.Addr(), 7, lpFileName, uintptr(dwDesiredAccess), uintptr(dwShareMode), lpSecurityAttributes,
|
|
uintptr(dwCreationDisposition), uintptr(dwFlagsAndAttributes), hTemplateFile, 0, 0)
|
|
h := syscall.Handle(r0)
|
|
if h == syscall.InvalidHandle {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
return r0
|
|
}
|
|
return uintptr(h)
|
|
|
|
}
|
|
|
|
// HANDLE CreateFileMappingA(
|
|
//
|
|
// HANDLE hFile,
|
|
// LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
|
|
// DWORD flProtect,
|
|
// DWORD dwMaximumSizeHigh,
|
|
// DWORD dwMaximumSizeLow,
|
|
// LPCSTR lpName
|
|
//
|
|
// );
|
|
func XCreateFileMappingA(t *TLS, hFile, lpFileMappingAttributes uintptr, flProtect, dwMaximumSizeHigh, dwMaximumSizeLow uint32, lpName uintptr) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// HANDLE CreateFileMappingW(
|
|
//
|
|
// HANDLE hFile,
|
|
// LPSECURITY_ATTRIBUTES lpFileMappingAttributes,
|
|
// DWORD flProtect,
|
|
// DWORD dwMaximumSizeHigh,
|
|
// DWORD dwMaximumSizeLow,
|
|
// LPCWSTR lpName
|
|
//
|
|
// );
|
|
func XCreateFileMappingW(t *TLS, hFile, lpFileMappingAttributes uintptr, flProtect, dwMaximumSizeHigh, dwMaximumSizeLow uint32, lpName uintptr) uintptr {
|
|
h, _, e1 := syscall.Syscall6(procCreateFileMappingW.Addr(), 6, hFile, lpFileMappingAttributes, uintptr(flProtect),
|
|
uintptr(dwMaximumSizeHigh), uintptr(dwMaximumSizeLow), lpName)
|
|
if h == 0 {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
}
|
|
return h
|
|
}
|
|
|
|
// HANDLE CreateMutexW(
|
|
//
|
|
// LPSECURITY_ATTRIBUTES lpMutexAttributes,
|
|
// BOOL bInitialOwner,
|
|
// LPCWSTR lpName
|
|
//
|
|
// );
|
|
func XCreateMutexW(t *TLS, lpMutexAttributes uintptr, bInitialOwner int32, lpName uintptr) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// BOOL DeleteFileA(
|
|
//
|
|
// LPCSTR lpFileName
|
|
//
|
|
// );
|
|
func XDeleteFileA(t *TLS, lpFileName uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// DWORD FormatMessageA(
|
|
//
|
|
// DWORD dwFlags,
|
|
// LPCVOID lpSource,
|
|
// DWORD dwMessageId,
|
|
// DWORD dwLanguageId,
|
|
// LPSTR lpBuffer,
|
|
// DWORD nSize,
|
|
// va_list *Arguments
|
|
//
|
|
// );
|
|
func XFormatMessageA(t *TLS, dwFlagsAndAttributes uint32, lpSource uintptr, dwMessageId, dwLanguageId uint32, lpBuffer uintptr, nSize uint32, Arguments uintptr) uint32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// DWORD FormatMessageW(
|
|
//
|
|
// DWORD dwFlags,
|
|
// LPCVOID lpSource,
|
|
// DWORD dwMessageId,
|
|
// DWORD dwLanguageId,
|
|
// LPWSTR lpBuffer,
|
|
// DWORD nSize,
|
|
// va_list *Arguments
|
|
//
|
|
// );
|
|
func XFormatMessageW(t *TLS, dwFlags uint32, lpSource uintptr, dwMessageId, dwLanguageId uint32, lpBuffer uintptr, nSize uint32, Arguments uintptr) uint32 {
|
|
r0, _, e1 := syscall.Syscall9(procFormatMessageW.Addr(), 7,
|
|
uintptr(dwFlags), lpSource, uintptr(dwMessageId), uintptr(dwLanguageId),
|
|
lpBuffer, uintptr(nSize), Arguments, 0, 0)
|
|
n := uint32(r0)
|
|
if n == 0 {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
// BOOL FreeLibrary(HMODULE hLibModule);
|
|
func XFreeLibrary(t *TLS, hLibModule uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// DWORD GetCurrentProcessId();
|
|
func XGetCurrentProcessId(t *TLS) uint32 {
|
|
r0, _, _ := syscall.Syscall(procGetCurrentProcessId.Addr(), 0, 0, 0, 0)
|
|
pid := uint32(r0)
|
|
return pid
|
|
}
|
|
|
|
// BOOL GetDiskFreeSpaceA(
|
|
//
|
|
// LPCSTR lpRootPathName,
|
|
// LPDWORD lpSectorsPerCluster,
|
|
// LPDWORD lpBytesPerSector,
|
|
// LPDWORD lpNumberOfFreeClusters,
|
|
// LPDWORD lpTotalNumberOfClusters
|
|
//
|
|
// );
|
|
func XGetDiskFreeSpaceA(t *TLS, lpRootPathName, lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// BOOL GetDiskFreeSpaceW(
|
|
//
|
|
// LPCWSTR lpRootPathName,
|
|
// LPDWORD lpSectorsPerCluster,
|
|
// LPDWORD lpBytesPerSector,
|
|
// LPDWORD lpNumberOfFreeClusters,
|
|
// LPDWORD lpTotalNumberOfClusters
|
|
//
|
|
// );
|
|
func XGetDiskFreeSpaceW(t *TLS, lpRootPathName, lpSectorsPerCluster, lpBytesPerSector, lpNumberOfFreeClusters, lpTotalNumberOfClusters uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// DWORD GetFileAttributesA(
|
|
//
|
|
// LPCSTR lpFileName
|
|
//
|
|
// );
|
|
func XGetFileAttributesA(t *TLS, lpFileName uintptr) uint32 {
|
|
r0, _, err := syscall.Syscall(procGetFileAttributesA.Addr(), 1, lpFileName, 0, 0)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return uint32(r0)
|
|
}
|
|
|
|
// BOOL GetFileAttributesExW(
|
|
//
|
|
// LPCWSTR lpFileName,
|
|
// GET_FILEEX_INFO_LEVELS fInfoLevelId,
|
|
// LPVOID lpFileInformation
|
|
//
|
|
// );
|
|
func XGetFileAttributesExW(t *TLS, lpFileName uintptr, fInfoLevelId uint32, lpFileInformation uintptr) int32 {
|
|
r1, _, e1 := syscall.Syscall(procGetFileAttributesExW.Addr(), 3, lpFileName, uintptr(fInfoLevelId), lpFileInformation)
|
|
if r1 == 0 {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
return 0
|
|
}
|
|
return int32(r1)
|
|
}
|
|
|
|
// DWORD GetFileSize(
|
|
//
|
|
// HANDLE hFile,
|
|
// LPDWORD lpFileSizeHigh
|
|
//
|
|
// );
|
|
func XGetFileSize(t *TLS, hFile, lpFileSizeHigh uintptr) uint32 {
|
|
r1, _, e1 := syscall.Syscall(procGetFileSize.Addr(), 2, hFile, lpFileSizeHigh, 0)
|
|
if r1 == math.MaxUint32 {
|
|
if lpFileSizeHigh == 0 {
|
|
// If the function fails and lpFileSizeHigh is NULL, the return value is INVALID_FILE_SIZE.
|
|
// Note that if the return value is INVALID_FILE_SIZE (0xffffffff),
|
|
// an application must call GetLastError to determine whether the function has succeeded or failed.
|
|
t.setErrno(e1)
|
|
return math.MaxUint32
|
|
} else {
|
|
// If the function fails and lpFileSizeHigh is non-NULL, the return value is INVALID_FILE_SIZE
|
|
// and GetLastError will return a value other than NO_ERROR.
|
|
t.setErrno(e1)
|
|
return math.MaxUint32
|
|
}
|
|
}
|
|
return uint32(r1)
|
|
}
|
|
|
|
// DWORD GetFullPathNameA(
|
|
//
|
|
// LPCSTR lpFileName,
|
|
// DWORD nBufferLength,
|
|
// LPSTR lpBuffer,
|
|
// LPSTR *lpFilePart
|
|
//
|
|
// );
|
|
func XGetFullPathNameA(t *TLS, lpFileName uintptr, nBufferLength uint32, lpBuffer, lpFilePart uintptr) uint32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// FARPROC GetProcAddress(HMODULE hModule, LPCSTR lpProcName);
|
|
func XGetProcAddress(t *TLS, hModule, lpProcName uintptr) uintptr {
|
|
|
|
return 0
|
|
|
|
//panic(todo(GoString(lpProcName)))
|
|
//
|
|
//r0, _, err := syscall.Syscall(procGetProcAddress.Addr(), 2, hModule, lpProcName, 0)
|
|
//if r0 == 0 {
|
|
// t.setErrno(err)
|
|
//}
|
|
//return r0
|
|
}
|
|
|
|
// NTSYSAPI NTSTATUS RtlGetVersion( // ntdll.dll
|
|
//
|
|
// PRTL_OSVERSIONINFOW lpVersionInformation
|
|
//
|
|
// );
|
|
func XRtlGetVersion(t *TLS, lpVersionInformation uintptr) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// void GetSystemInfo(
|
|
//
|
|
// LPSYSTEM_INFO lpSystemInfo
|
|
//
|
|
// );
|
|
func XGetSystemInfo(t *TLS, lpSystemInfo uintptr) {
|
|
syscall.Syscall(procGetSystemInfo.Addr(), 1, lpSystemInfo, 0, 0)
|
|
}
|
|
|
|
// void GetSystemTime(LPSYSTEMTIME lpSystemTime);
|
|
func XGetSystemTime(t *TLS, lpSystemTime uintptr) {
|
|
syscall.Syscall(procGetSystemTime.Addr(), 1, lpSystemTime, 0, 0)
|
|
}
|
|
|
|
// void GetSystemTimeAsFileTime(
|
|
//
|
|
// LPFILETIME lpSystemTimeAsFileTime
|
|
//
|
|
// );
|
|
func XGetSystemTimeAsFileTime(t *TLS, lpSystemTimeAsFileTime uintptr) {
|
|
syscall.Syscall(procGetSystemTimeAsFileTime.Addr(), 1, lpSystemTimeAsFileTime, 0, 0)
|
|
}
|
|
|
|
// DWORD GetTempPathA(
|
|
//
|
|
// DWORD nBufferLength,
|
|
// LPSTR lpBuffer
|
|
//
|
|
// );
|
|
func XGetTempPathA(t *TLS, nBufferLength uint32, lpBuffer uintptr) uint32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// DWORD GetTempPathW(
|
|
//
|
|
// DWORD nBufferLength,
|
|
// LPWSTR lpBuffer
|
|
//
|
|
// );
|
|
func XGetTempPathW(t *TLS, nBufferLength uint32, lpBuffer uintptr) uint32 {
|
|
rv, err := syscall.GetTempPath(nBufferLength, (*uint16)(unsafe.Pointer(lpBuffer)))
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
}
|
|
return rv
|
|
}
|
|
|
|
// DWORD GetTickCount();
|
|
func XGetTickCount(t *TLS) uint32 {
|
|
r0, _, _ := syscall.Syscall(procGetTickCount.Addr(), 0, 0, 0, 0)
|
|
return uint32(r0)
|
|
}
|
|
|
|
// BOOL GetVersionExA(
|
|
//
|
|
// LPOSVERSIONINFOA lpVersionInformation
|
|
//
|
|
// );
|
|
func XGetVersionExA(t *TLS, lpVersionInformation uintptr) int32 {
|
|
r0, _, err := syscall.Syscall(procGetVersionExA.Addr(), 1, lpVersionInformation, 0, 0)
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// HANDLE HeapCreate(
|
|
//
|
|
// DWORD flOptions,
|
|
// SIZE_T dwInitialSize,
|
|
// SIZE_T dwMaximumSize
|
|
//
|
|
// );
|
|
func XHeapCreate(t *TLS, flOptions uint32, dwInitialSize, dwMaximumSize types.Size_t) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// BOOL HeapDestroy(
|
|
//
|
|
// HANDLE hHeap
|
|
//
|
|
// );
|
|
func XHeapDestroy(t *TLS, hHeap uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// LPVOID HeapReAlloc(
|
|
//
|
|
// HANDLE hHeap,
|
|
// DWORD dwFlags,
|
|
// _Frees_ptr_opt_ LPVOID lpMem,
|
|
// SIZE_T dwBytes
|
|
//
|
|
// );
|
|
func XHeapReAlloc(t *TLS, hHeap uintptr, dwFlags uint32, lpMem uintptr, dwBytes types.Size_t) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// SIZE_T HeapSize(
|
|
//
|
|
// HANDLE hHeap,
|
|
// DWORD dwFlags,
|
|
// LPCVOID lpMem
|
|
//
|
|
// );
|
|
func XHeapSize(t *TLS, hHeap uintptr, dwFlags uint32, lpMem uintptr) types.Size_t {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// BOOL HeapValidate(
|
|
//
|
|
// HANDLE hHeap,
|
|
// DWORD dwFlags,
|
|
// LPCVOID lpMem
|
|
//
|
|
// );
|
|
func XHeapValidate(t *TLS, hHeap uintptr, dwFlags uint32, lpMem uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// SIZE_T HeapCompact(
|
|
//
|
|
// HANDLE hHeap,
|
|
// DWORD dwFlags
|
|
//
|
|
// );
|
|
func XHeapCompact(t *TLS, hHeap uintptr, dwFlags uint32) types.Size_t {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// HMODULE LoadLibraryA(LPCSTR lpLibFileName);
|
|
func XLoadLibraryA(t *TLS, lpLibFileName uintptr) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// HMODULE LoadLibraryW(
|
|
//
|
|
// LPCWSTR lpLibFileName
|
|
//
|
|
// );
|
|
func XLoadLibraryW(t *TLS, lpLibFileName uintptr) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// HLOCAL LocalFree(
|
|
//
|
|
// HLOCAL hMem
|
|
//
|
|
// );
|
|
func XLocalFree(t *TLS, hMem uintptr) uintptr {
|
|
h, err := syscall.LocalFree(syscall.Handle(hMem))
|
|
if h != 0 {
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
return uintptr(h)
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// BOOL LockFile(
|
|
//
|
|
// HANDLE hFile,
|
|
// DWORD dwFileOffsetLow,
|
|
// DWORD dwFileOffsetHigh,
|
|
// DWORD nNumberOfBytesToLockLow,
|
|
// DWORD nNumberOfBytesToLockHigh
|
|
//
|
|
// );
|
|
func XLockFile(t *TLS, hFile uintptr, dwFileOffsetLow, dwFileOffsetHigh, nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh uint32) int32 {
|
|
|
|
r1, _, e1 := syscall.Syscall6(procLockFile.Addr(), 5,
|
|
hFile, uintptr(dwFileOffsetLow), uintptr(dwFileOffsetHigh), uintptr(nNumberOfBytesToLockLow), uintptr(nNumberOfBytesToLockHigh), 0)
|
|
if r1 == 0 {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
return 0
|
|
}
|
|
return int32(r1)
|
|
|
|
}
|
|
|
|
// BOOL LockFileEx(
|
|
//
|
|
// HANDLE hFile,
|
|
// DWORD dwFlags,
|
|
// DWORD dwReserved,
|
|
// DWORD nNumberOfBytesToLockLow,
|
|
// DWORD nNumberOfBytesToLockHigh,
|
|
// LPOVERLAPPED lpOverlapped
|
|
//
|
|
// );
|
|
func XLockFileEx(t *TLS, hFile uintptr, dwFlags, dwReserved, nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh uint32, lpOverlapped uintptr) int32 {
|
|
r1, _, e1 := syscall.Syscall6(procLockFileEx.Addr(), 6,
|
|
hFile, uintptr(dwFlags), uintptr(dwReserved), uintptr(nNumberOfBytesToLockLow), uintptr(nNumberOfBytesToLockHigh), lpOverlapped)
|
|
if r1 == 0 {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
return 0
|
|
}
|
|
return int32(r1)
|
|
}
|
|
|
|
// LPVOID MapViewOfFile(
|
|
//
|
|
// HANDLE hFileMappingObject,
|
|
// DWORD dwDesiredAccess,
|
|
// DWORD dwFileOffsetHigh,
|
|
// DWORD dwFileOffsetLow,
|
|
// SIZE_T dwNumberOfBytesToMap
|
|
//
|
|
// );
|
|
func XMapViewOfFile(t *TLS, hFileMappingObject uintptr, dwDesiredAccess, dwFileOffsetHigh, dwFileOffsetLow uint32, dwNumberOfBytesToMap types.Size_t) uintptr {
|
|
h, _, e1 := syscall.Syscall6(procMapViewOfFile.Addr(), 5, hFileMappingObject, uintptr(dwDesiredAccess),
|
|
uintptr(dwFileOffsetHigh), uintptr(dwFileOffsetLow), uintptr(dwNumberOfBytesToMap), 0)
|
|
if h == 0 {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
}
|
|
return h
|
|
}
|
|
|
|
// BOOL QueryPerformanceCounter(
|
|
//
|
|
// LARGE_INTEGER *lpPerformanceCount
|
|
//
|
|
// );
|
|
func XQueryPerformanceCounter(t *TLS, lpPerformanceCount uintptr) int32 {
|
|
r0, _, _ := syscall.Syscall(procQueryPerformanceCounter.Addr(), 1, lpPerformanceCount, 0, 0)
|
|
return int32(r0)
|
|
}
|
|
|
|
// void Sleep(
|
|
//
|
|
// DWORD dwMilliseconds
|
|
//
|
|
// );
|
|
func XSleep(t *TLS, dwMilliseconds uint32) {
|
|
gotime.Sleep(gotime.Duration(dwMilliseconds) * gotime.Millisecond)
|
|
}
|
|
|
|
// BOOL SystemTimeToFileTime(const SYSTEMTIME *lpSystemTime, LPFILETIME lpFileTime);
|
|
func XSystemTimeToFileTime(t *TLS, lpSystemTime, lpFileTime uintptr) int32 {
|
|
r0, _, _ := syscall.Syscall(procSystemTimeToFileTime.Addr(), 2, lpSystemTime, lpFileTime, 0)
|
|
return int32(r0)
|
|
}
|
|
|
|
// BOOL UnlockFile(
|
|
//
|
|
// HANDLE hFile,
|
|
// DWORD dwFileOffsetLow,
|
|
// DWORD dwFileOffsetHigh,
|
|
// DWORD nNumberOfBytesToUnlockLow,
|
|
// DWORD nNumberOfBytesToUnlockHigh
|
|
//
|
|
// );
|
|
func XUnlockFile(t *TLS, hFile uintptr, dwFileOffsetLow, dwFileOffsetHigh, nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh uint32) int32 {
|
|
r1, _, e1 := syscall.Syscall6(procUnlockFile.Addr(), 5,
|
|
hFile, uintptr(dwFileOffsetLow), uintptr(dwFileOffsetHigh), uintptr(nNumberOfBytesToUnlockLow), uintptr(nNumberOfBytesToUnlockHigh), 0)
|
|
if r1 == 0 {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
return 0
|
|
}
|
|
return int32(r1)
|
|
}
|
|
|
|
// BOOL UnlockFileEx(
|
|
//
|
|
// HANDLE hFile,
|
|
// DWORD dwReserved,
|
|
// DWORD nNumberOfBytesToUnlockLow,
|
|
// DWORD nNumberOfBytesToUnlockHigh,
|
|
// LPOVERLAPPED lpOverlapped
|
|
//
|
|
// );
|
|
func XUnlockFileEx(t *TLS, hFile uintptr, dwReserved, nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh uint32, lpOverlapped uintptr) int32 {
|
|
r1, _, e1 := syscall.Syscall6(procUnlockFileEx.Addr(), 5,
|
|
hFile, uintptr(dwReserved), uintptr(nNumberOfBytesToUnlockLow), uintptr(nNumberOfBytesToUnlockHigh), lpOverlapped, 0)
|
|
if r1 == 0 {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
return 0
|
|
}
|
|
return int32(r1)
|
|
}
|
|
|
|
// BOOL UnmapViewOfFile(
|
|
//
|
|
// LPCVOID lpBaseAddress
|
|
//
|
|
// );
|
|
func XUnmapViewOfFile(t *TLS, lpBaseAddress uintptr) int32 {
|
|
err := syscall.UnmapViewOfFile(lpBaseAddress)
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
return 0
|
|
}
|
|
return 1
|
|
}
|
|
|
|
// int WideCharToMultiByte(
|
|
//
|
|
// UINT CodePage,
|
|
// DWORD dwFlags,
|
|
// _In_NLS_string_(cchWideChar)LPCWCH lpWideCharStr,
|
|
// int cchWideChar,
|
|
// LPSTR lpMultiByteStr,
|
|
// int cbMultiByte,
|
|
// LPCCH lpDefaultChar,
|
|
// LPBOOL lpUsedDefaultChar
|
|
//
|
|
// );
|
|
func XWideCharToMultiByte(t *TLS, CodePage uint32, dwFlags uint32, lpWideCharStr uintptr, cchWideChar int32, lpMultiByteStr uintptr, cbMultiByte int32, lpDefaultChar, lpUsedDefaultChar uintptr) int32 {
|
|
r1, _, _ := syscall.Syscall9(procWideCharToMultiByte.Addr(), 8,
|
|
uintptr(CodePage), uintptr(dwFlags), lpWideCharStr,
|
|
uintptr(cchWideChar), lpMultiByteStr, uintptr(cbMultiByte),
|
|
lpDefaultChar, lpUsedDefaultChar, 0)
|
|
return (int32(r1))
|
|
}
|
|
|
|
// void OutputDebugStringA(
|
|
//
|
|
// LPCSTR lpOutputString
|
|
//
|
|
// )
|
|
func XOutputDebugStringA(t *TLS, lpOutputString uintptr) {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// BOOL FlushViewOfFile(
|
|
//
|
|
// LPCVOID lpBaseAddress,
|
|
// SIZE_T dwNumberOfBytesToFlush
|
|
//
|
|
// );
|
|
func XFlushViewOfFile(t *TLS, lpBaseAddress uintptr, dwNumberOfBytesToFlush types.Size_t) int32 {
|
|
err := syscall.FlushViewOfFile(lpBaseAddress, uintptr(dwNumberOfBytesToFlush))
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
return 0
|
|
}
|
|
return 1
|
|
}
|
|
|
|
type _ino_t = uint16 /* types.h:43:24 */
|
|
type _dev_t = uint32 /* types.h:51:22 */
|
|
type _stat64 = struct {
|
|
Fst_dev _dev_t
|
|
Fst_ino _ino_t
|
|
Fst_mode uint16
|
|
Fst_nlink int16
|
|
Fst_uid int16
|
|
Fst_gid int16
|
|
_ [2]byte
|
|
Fst_rdev _dev_t
|
|
_ [4]byte
|
|
Fst_size int64
|
|
Fst_atime int64
|
|
Fst_mtime int64
|
|
Fst_ctime int64
|
|
} /* _mingw_stat64.h:83:3 */
|
|
|
|
var (
|
|
Windows_Tick int64 = 10000000
|
|
SecToUnixEpoch int64 = 11644473600
|
|
)
|
|
|
|
func WindowsTickToUnixSeconds(windowsTicks int64) int64 {
|
|
return (windowsTicks/Windows_Tick - SecToUnixEpoch)
|
|
}
|
|
|
|
// int _stat64(const char *path, struct __stat64 *buffer);
|
|
func X_stat64(t *TLS, path, buffer uintptr) int32 {
|
|
|
|
var fa syscall.Win32FileAttributeData
|
|
r1, _, e1 := syscall.Syscall(procGetFileAttributesExA.Addr(), 3, path, syscall.GetFileExInfoStandard, (uintptr)(unsafe.Pointer(&fa)))
|
|
if r1 == 0 {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
return -1
|
|
}
|
|
|
|
var bStat64 = (*_stat64)(unsafe.Pointer(buffer))
|
|
var accessTime = int64(fa.LastAccessTime.HighDateTime)<<32 + int64(fa.LastAccessTime.LowDateTime)
|
|
bStat64.Fst_atime = WindowsTickToUnixSeconds(accessTime)
|
|
var modTime = int64(fa.LastWriteTime.HighDateTime)<<32 + int64(fa.LastWriteTime.LowDateTime)
|
|
bStat64.Fst_mtime = WindowsTickToUnixSeconds(modTime)
|
|
var crTime = int64(fa.CreationTime.HighDateTime)<<32 + int64(fa.CreationTime.LowDateTime)
|
|
bStat64.Fst_ctime = WindowsTickToUnixSeconds(crTime)
|
|
var fSz = int64(fa.FileSizeHigh)<<32 + int64(fa.FileSizeLow)
|
|
bStat64.Fst_size = fSz
|
|
bStat64.Fst_mode = WindowsAttrbiutesToStat(fa.FileAttributes)
|
|
|
|
return 0
|
|
}
|
|
|
|
func WindowsAttrbiutesToStat(fa uint32) uint16 {
|
|
var src_mode = fa & 0xff
|
|
var st_mode uint16
|
|
if (src_mode & syscall.FILE_ATTRIBUTE_DIRECTORY) != 0 {
|
|
st_mode = syscall.S_IFDIR
|
|
} else {
|
|
st_mode = syscall.S_IFREG
|
|
}
|
|
|
|
if src_mode&syscall.FILE_ATTRIBUTE_READONLY != 0 {
|
|
st_mode = st_mode | syscall.S_IRUSR
|
|
} else {
|
|
st_mode = st_mode | syscall.S_IRUSR | syscall.S_IWUSR
|
|
}
|
|
// fill group fields
|
|
st_mode = st_mode | (st_mode&0x700)>>3
|
|
st_mode = st_mode | (st_mode&0x700)>>6
|
|
return st_mode
|
|
}
|
|
|
|
// int _chsize(
|
|
//
|
|
// int fd,
|
|
// long size
|
|
//
|
|
// );
|
|
func X_chsize(t *TLS, fd int32, size long) int32 {
|
|
|
|
f, ok := fdToFile(fd)
|
|
if !ok {
|
|
t.setErrno(EBADF)
|
|
return -1
|
|
}
|
|
|
|
err := syscall.Ftruncate(f.Handle, int64(size))
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
return -1
|
|
}
|
|
|
|
return 0
|
|
}
|
|
|
|
// int _snprintf(char *str, size_t size, const char *format, ...);
|
|
func X_snprintf(t *TLS, str uintptr, size types.Size_t, format, args uintptr) int32 {
|
|
return Xsnprintf(t, str, size, format, args)
|
|
}
|
|
|
|
const wErr_ERROR_INSUFFICIENT_BUFFER = 122
|
|
|
|
func win32FindDataToFileInfo(t *TLS, fdata *stat.X_finddata64i32_t, wfd *syscall.Win32finddata) int32 {
|
|
// t64 = 64-bit time value
|
|
var accessTime = int64(wfd.LastAccessTime.HighDateTime)<<32 + int64(wfd.LastAccessTime.LowDateTime)
|
|
fdata.Ftime_access = WindowsTickToUnixSeconds(accessTime)
|
|
var modTime = int64(wfd.LastWriteTime.HighDateTime)<<32 + int64(wfd.LastWriteTime.LowDateTime)
|
|
fdata.Ftime_write = WindowsTickToUnixSeconds(modTime)
|
|
var crTime = int64(wfd.CreationTime.HighDateTime)<<32 + int64(wfd.CreationTime.LowDateTime)
|
|
fdata.Ftime_create = WindowsTickToUnixSeconds(crTime)
|
|
// i32 = 32-bit size
|
|
fdata.Fsize = wfd.FileSizeLow
|
|
fdata.Fattrib = wfd.FileAttributes
|
|
|
|
var cp = XGetConsoleCP(t)
|
|
var wcFn = (uintptr)(unsafe.Pointer(&wfd.FileName[0]))
|
|
var mbcsFn = (uintptr)(unsafe.Pointer(&fdata.Fname[0]))
|
|
rv := XWideCharToMultiByte(t, cp, 0, wcFn, -1, mbcsFn, 260, 0, 0)
|
|
if rv == wErr_ERROR_INSUFFICIENT_BUFFER {
|
|
t.setErrno(errno.ENOMEM)
|
|
return -1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// intptr_t _findfirst64i32(
|
|
//
|
|
// const char *filespec,
|
|
// struct _finddata64i32_t *fileinfo
|
|
//
|
|
// );
|
|
func X_findfirst64i32(t *TLS, filespec, fileinfo uintptr) types.Intptr_t {
|
|
|
|
// Note: this is the 'narrow' character findfirst -- expects output
|
|
// as mbcs -- conversion below -- via ToFileInfo
|
|
|
|
var gsFileSpec = GoString(filespec)
|
|
namep, err := syscall.UTF16PtrFromString(gsFileSpec)
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
return types.Intptr_t(-1)
|
|
}
|
|
|
|
var fdata = (*stat.X_finddata64i32_t)(unsafe.Pointer(fileinfo))
|
|
var wfd syscall.Win32finddata
|
|
h, err := syscall.FindFirstFile((*uint16)(unsafe.Pointer(namep)), &wfd)
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
return types.Intptr_t(-1)
|
|
}
|
|
rv := win32FindDataToFileInfo(t, fdata, &wfd)
|
|
if rv != 0 {
|
|
if h != 0 {
|
|
syscall.FindClose(h)
|
|
}
|
|
return types.Intptr_t(-1)
|
|
}
|
|
return types.Intptr_t(h)
|
|
}
|
|
|
|
// int _findnext64i32(
|
|
//
|
|
// intptr_t handle,
|
|
// struct _finddata64i32_t *fileinfo
|
|
//
|
|
// );
|
|
func X_findnext64i32(t *TLS, handle types.Intptr_t, fileinfo uintptr) int32 {
|
|
|
|
var fdata = (*stat.X_finddata64i32_t)(unsafe.Pointer(fileinfo))
|
|
var wfd syscall.Win32finddata
|
|
|
|
err := syscall.FindNextFile(syscall.Handle(handle), &wfd)
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
return -1
|
|
}
|
|
|
|
rv := win32FindDataToFileInfo(t, fdata, &wfd)
|
|
if rv != 0 {
|
|
return -1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// int _findclose(
|
|
//
|
|
// intptr_t handle
|
|
//
|
|
// );
|
|
func X_findclose(t *TLS, handle types.Intptr_t) int32 {
|
|
|
|
err := syscall.FindClose(syscall.Handle(handle))
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
return -1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// DWORD GetEnvironmentVariableA(
|
|
//
|
|
// LPCSTR lpName,
|
|
// LPSTR lpBuffer,
|
|
// DWORD nSize
|
|
//
|
|
// );
|
|
func XGetEnvironmentVariableA(t *TLS, lpName, lpBuffer uintptr, nSize uint32) uint32 {
|
|
r0, _, e1 := syscall.Syscall(procGetEnvironmentVariableA.Addr(), 3, lpName, lpBuffer, uintptr(nSize))
|
|
n := uint32(r0)
|
|
if n == 0 {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
// int _fstat64(
|
|
//
|
|
// int fd,
|
|
// struct __stat64 *buffer
|
|
//
|
|
// );
|
|
func X_fstat64(t *TLS, fd int32, buffer uintptr) int32 {
|
|
|
|
f, ok := fdToFile(fd)
|
|
if !ok {
|
|
t.setErrno(EBADF)
|
|
return -1
|
|
}
|
|
|
|
var d syscall.ByHandleFileInformation
|
|
err := syscall.GetFileInformationByHandle(f.Handle, &d)
|
|
if err != nil {
|
|
t.setErrno(EBADF)
|
|
return -1
|
|
}
|
|
|
|
var bStat64 = (*_stat64)(unsafe.Pointer(buffer))
|
|
var accessTime = int64(d.LastAccessTime.HighDateTime)<<32 + int64(d.LastAccessTime.LowDateTime)
|
|
bStat64.Fst_atime = WindowsTickToUnixSeconds(accessTime)
|
|
var modTime = int64(d.LastWriteTime.HighDateTime)<<32 + int64(d.LastWriteTime.LowDateTime)
|
|
bStat64.Fst_mtime = WindowsTickToUnixSeconds(modTime)
|
|
var crTime = int64(d.CreationTime.HighDateTime)<<32 + int64(d.CreationTime.LowDateTime)
|
|
bStat64.Fst_ctime = WindowsTickToUnixSeconds(crTime)
|
|
var fSz = int64(d.FileSizeHigh)<<32 + int64(d.FileSizeLow)
|
|
bStat64.Fst_size = fSz
|
|
bStat64.Fst_mode = WindowsAttrbiutesToStat(d.FileAttributes)
|
|
|
|
return 0
|
|
}
|
|
|
|
// HANDLE CreateEventA(
|
|
//
|
|
// LPSECURITY_ATTRIBUTES lpEventAttributes,
|
|
// BOOL bManualReset,
|
|
// BOOL bInitialState,
|
|
// LPCSTR lpName
|
|
//
|
|
// );
|
|
func XCreateEventA(t *TLS, lpEventAttributes uintptr, bManualReset, bInitialState int32, lpName uintptr) uintptr {
|
|
r0, _, err := syscall.Syscall6(procCreateEventA.Addr(), 4, lpEventAttributes, uintptr(bManualReset),
|
|
uintptr(bInitialState), lpName, 0, 0)
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// BOOL WINAPI CancelSynchronousIo(
|
|
//
|
|
// _In_ HANDLE hThread
|
|
//
|
|
// );
|
|
func XCancelSynchronousIo(t *TLS, hThread uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func X_endthreadex(t *TLS, _ ...interface{}) {
|
|
// NOOP
|
|
}
|
|
|
|
// The calling convention for beginthread is cdecl -- but in this
|
|
// case we're just intercepting it and sending it through CreateThread which expects stdcall
|
|
// and gets that via the go callback. This is safe because the thread is calling into go
|
|
// not a cdecl function which would expect the stack setup of cdecl.
|
|
func X_beginthread(t *TLS, procAddr uintptr, stack_sz uint32, args uintptr) int32 {
|
|
f := (*struct{ f func(*TLS, uintptr) uint32 })(unsafe.Pointer(&struct{ uintptr }{procAddr})).f
|
|
var tAdp = ThreadAdapter{threadFunc: f, tls: NewTLS(), param: args}
|
|
tAdp.token = addObject(&tAdp)
|
|
|
|
r0, _, err := syscall.Syscall6(procCreateThread.Addr(), 6, 0, uintptr(stack_sz),
|
|
threadCallback, tAdp.token, 0, 0)
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// uintptr_t _beginthreadex( // NATIVE CODE
|
|
//
|
|
// void *security,
|
|
// unsigned stack_size,
|
|
// unsigned ( __stdcall *start_address )( void * ),
|
|
// void *arglist,
|
|
// unsigned initflag,
|
|
// unsigned *thrdaddr
|
|
//
|
|
// );
|
|
func X_beginthreadex(t *TLS, _ uintptr, stack_sz uint32, procAddr uintptr, args uintptr, initf uint32, thAddr uintptr) int32 {
|
|
f := (*struct{ f func(*TLS, uintptr) uint32 })(unsafe.Pointer(&struct{ uintptr }{procAddr})).f
|
|
var tAdp = ThreadAdapter{threadFunc: f, tls: NewTLS(), param: args}
|
|
tAdp.token = addObject(&tAdp)
|
|
|
|
r0, _, err := syscall.Syscall6(procCreateThread.Addr(), 6, 0, uintptr(stack_sz),
|
|
threadCallback, tAdp.token, uintptr(initf), thAddr)
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// DWORD GetCurrentThreadId();
|
|
func XGetCurrentThreadId(t *TLS) uint32 {
|
|
r0, _, _ := syscall.Syscall(procGetCurrentThreadId.Addr(), 0, 0, 0, 0)
|
|
return uint32(r0)
|
|
//return uint32(t.ID)
|
|
}
|
|
|
|
// BOOL GetExitCodeThread(
|
|
//
|
|
// HANDLE hThread,
|
|
// LPDWORD lpExitCode
|
|
//
|
|
// );
|
|
func XGetExitCodeThread(t *TLS, hThread, lpExitCode uintptr) int32 {
|
|
r0, _, _ := syscall.Syscall(procGetExitCodeThread.Addr(), 2, hThread, lpExitCode, 0)
|
|
return int32(r0)
|
|
}
|
|
|
|
// DWORD WaitForSingleObjectEx(
|
|
//
|
|
// HANDLE hHandle,
|
|
// DWORD dwMilliseconds,
|
|
// BOOL bAlertable
|
|
//
|
|
// );
|
|
func XWaitForSingleObjectEx(t *TLS, hHandle uintptr, dwMilliseconds uint32, bAlertable int32) uint32 {
|
|
rv, _, _ := syscall.Syscall(procWaitForSingleObjectEx.Addr(), 3, hHandle, uintptr(dwMilliseconds), uintptr(bAlertable))
|
|
return uint32(rv)
|
|
}
|
|
|
|
// DWORD MsgWaitForMultipleObjectsEx(
|
|
//
|
|
// DWORD nCount,
|
|
// const HANDLE *pHandles,
|
|
// DWORD dwMilliseconds,
|
|
// DWORD dwWakeMask,
|
|
// DWORD dwFlags
|
|
//
|
|
// );
|
|
func XMsgWaitForMultipleObjectsEx(t *TLS, nCount uint32, pHandles uintptr, dwMilliseconds, dwWakeMask, dwFlags uint32) uint32 {
|
|
r0, _, err := syscall.Syscall6(procMsgWaitForMultipleObjectsEx.Addr(), 5,
|
|
uintptr(nCount),
|
|
pHandles,
|
|
uintptr(dwMilliseconds),
|
|
uintptr(dwWakeMask),
|
|
uintptr(dwFlags),
|
|
0,
|
|
)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return uint32(r0)
|
|
}
|
|
|
|
func XMessageBoxW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// DWORD GetModuleFileNameW(
|
|
//
|
|
// HMODULE hModule,
|
|
// LPWSTR lpFileName,
|
|
// DWORD nSize
|
|
//
|
|
// );
|
|
func XGetModuleFileNameW(t *TLS, hModule, lpFileName uintptr, nSize uint32) uint32 {
|
|
r0, _, err := syscall.Syscall(procGetModuleFileNameW.Addr(), 3, hModule, lpFileName, uintptr(nSize))
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return uint32(r0)
|
|
}
|
|
|
|
// NET_API_STATUS NET_API_FUNCTION NetGetDCName(
|
|
//
|
|
// LPCWSTR ServerName,
|
|
// LPCWSTR DomainName,
|
|
// LPBYTE *Buffer
|
|
//
|
|
// );
|
|
func XNetGetDCName(t *TLS, ServerName, DomainName, Buffer uintptr) int32 {
|
|
r0, _, err := syscall.Syscall(procNetGetDCName.Addr(), 3, ServerName, DomainName, Buffer)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// NET_API_STATUS NET_API_FUNCTION NetUserGetInfo(
|
|
//
|
|
// LPCWSTR servername,
|
|
// LPCWSTR username,
|
|
// DWORD level,
|
|
// LPBYTE *bufptr
|
|
//
|
|
// );
|
|
func XNetUserGetInfo(t *TLS, servername, username uintptr, level uint32, bufptr uintptr) uint32 {
|
|
r0, _, err := syscall.Syscall6(procNetUserGetInfo.Addr(), 4,
|
|
servername,
|
|
username,
|
|
uintptr(level),
|
|
bufptr,
|
|
0,
|
|
0,
|
|
)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return uint32(r0)
|
|
}
|
|
|
|
func XlstrlenW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// USERENVAPI BOOL GetProfilesDirectoryW(
|
|
//
|
|
// [out] LPWSTR lpProfileDir,
|
|
// [in, out] LPDWORD lpcchSize
|
|
//
|
|
// );
|
|
func XGetProfilesDirectoryW(t *TLS, lpProfileDir, lpcchSize uintptr) int32 {
|
|
r0, _, err := syscall.Syscall(procGetProfilesDirectoryW.Addr(), 2, lpProfileDir, lpcchSize, 0)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
func XNetApiBufferFree(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// DWORD GetPrivateProfileStringA(
|
|
//
|
|
// LPCSTR lpAppName,
|
|
// LPCSTR lpKeyName,
|
|
// LPCSTR lpDefault,
|
|
// LPSTR lpReturnedString,
|
|
// DWORD nSize,
|
|
// LPCSTR lpFileName
|
|
//
|
|
// );
|
|
func XGetPrivateProfileStringA(t *TLS, lpAppName, lpKeyName, lpDefault, lpReturnedString uintptr, nSize uint32, lpFileName uintptr) uint32 {
|
|
r0, _, err := syscall.Syscall6(procGetPrivateProfileStringA.Addr(), 4,
|
|
lpAppName,
|
|
lpKeyName,
|
|
lpDefault,
|
|
lpReturnedString,
|
|
uintptr(nSize),
|
|
lpFileName,
|
|
)
|
|
if err != 0 {
|
|
t.setErrno(0x02)
|
|
}
|
|
return uint32(r0)
|
|
}
|
|
|
|
func XGetWindowsDirectoryA(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// BOOL GetFileSecurityW(
|
|
//
|
|
// LPCSTR lpFileName,
|
|
// SECURITY_INFORMATION RequestedInformation,
|
|
// PSECURITY_DESCRIPTOR pSecurityDescriptor,
|
|
// DWORD nLength,
|
|
// LPDWORD lpnLengthNeeded
|
|
//
|
|
// );
|
|
func XGetFileSecurityW(t *TLS, lpFileName uintptr, RequestedInformation uint32, pSecurityDescriptor uintptr, nLength uint32, lpnLengthNeeded uintptr) int32 {
|
|
r0, _, err := syscall.Syscall6(procGetFileSecurityW.Addr(), 5, lpFileName, uintptr(RequestedInformation), pSecurityDescriptor, uintptr(nLength), lpnLengthNeeded, 0)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// BOOL GetSecurityDescriptorOwner(
|
|
//
|
|
// PSECURITY_DESCRIPTOR pSecurityDescriptor,
|
|
// PSID *pOwner,
|
|
// LPBOOL lpbOwnerDefaulted
|
|
//
|
|
// );
|
|
func XGetSecurityDescriptorOwner(t *TLS, pSecurityDescriptor, pOwner, lpbOwnerDefaulted uintptr) int32 {
|
|
r0, _, err := syscall.Syscall(procGetSecurityDescriptorOwner.Addr(), 3, pSecurityDescriptor, pOwner, lpbOwnerDefaulted)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
|
|
}
|
|
|
|
// PSID_IDENTIFIER_AUTHORITY GetSidIdentifierAuthority(
|
|
//
|
|
// PSID pSid
|
|
//
|
|
// );
|
|
func XGetSidIdentifierAuthority(t *TLS, pSid uintptr) uintptr {
|
|
r0, _, err := syscall.Syscall(procGetSidIdentifierAuthority.Addr(), 1, pSid, 0, 0)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// BOOL ImpersonateSelf(
|
|
//
|
|
// SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
|
|
//
|
|
// );
|
|
func XImpersonateSelf(t *TLS, ImpersonationLevel int32) int32 {
|
|
r0, _, err := syscall.Syscall(procImpersonateSelf.Addr(), 1, uintptr(ImpersonationLevel), 0, 0)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// BOOL OpenThreadToken(
|
|
//
|
|
// HANDLE ThreadHandle,
|
|
// DWORD DesiredAccess,
|
|
// BOOL OpenAsSelf,
|
|
// PHANDLE TokenHandle
|
|
//
|
|
// );
|
|
func XOpenThreadToken(t *TLS, ThreadHandle uintptr, DesiredAccess uint32, OpenAsSelf int32, TokenHandle uintptr) int32 {
|
|
r0, _, err := syscall.Syscall6(procOpenThreadToken.Addr(), 4, ThreadHandle, uintptr(DesiredAccess), uintptr(OpenAsSelf), TokenHandle, 0, 0)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// HANDLE GetCurrentThread();
|
|
func XGetCurrentThread(t *TLS) uintptr {
|
|
r0, _, err := syscall.Syscall(procGetCurrentThread.Addr(), 0, 0, 0, 0)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// BOOL RevertToSelf();
|
|
func XRevertToSelf(t *TLS) int32 {
|
|
r0, _, err := syscall.Syscall(procRevertToSelf.Addr(), 0, 0, 0, 0)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// BOOL AccessCheck(
|
|
//
|
|
// PSECURITY_DESCRIPTOR pSecurityDescriptor,
|
|
// HANDLE ClientToken,
|
|
// DWORD DesiredAccess,
|
|
// PGENERIC_MAPPING GenericMapping,
|
|
// PPRIVILEGE_SET PrivilegeSet,
|
|
// LPDWORD PrivilegeSetLength,
|
|
// LPDWORD GrantedAccess,
|
|
// LPBOOL AccessStatus
|
|
//
|
|
// );
|
|
func XAccessCheck(t *TLS, pSecurityDescriptor, ClientToken uintptr, DesiredAccess uint32, GenericMapping, PrivilegeSet, PrivilegeSetLength, GrantedAccess, AccessStatus uintptr) int32 {
|
|
r0, _, err := syscall.Syscall9(procAccessCheck.Addr(), 8,
|
|
pSecurityDescriptor,
|
|
ClientToken,
|
|
uintptr(DesiredAccess),
|
|
GenericMapping,
|
|
PrivilegeSet,
|
|
PrivilegeSetLength,
|
|
GrantedAccess,
|
|
AccessStatus,
|
|
0,
|
|
)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// int _wcsicmp(
|
|
//
|
|
// const wchar_t *string1,
|
|
// const wchar_t *string2
|
|
//
|
|
// );
|
|
func Xwcsicmp(t *TLS, string1, string2 uintptr) int32 {
|
|
var s1 = strings.ToLower(goWideString(string1))
|
|
var s2 = strings.ToLower(goWideString(string2))
|
|
return int32(strings.Compare(s1, s2))
|
|
}
|
|
|
|
// BOOL SetCurrentDirectoryW(
|
|
//
|
|
// LPCTSTR lpPathName
|
|
//
|
|
// );
|
|
func XSetCurrentDirectoryW(t *TLS, lpPathName uintptr) int32 {
|
|
err := syscall.SetCurrentDirectory((*uint16)(unsafe.Pointer(lpPathName)))
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
return 0
|
|
}
|
|
return 1
|
|
}
|
|
|
|
// DWORD GetCurrentDirectory(
|
|
//
|
|
// DWORD nBufferLength,
|
|
// LPWTSTR lpBuffer
|
|
//
|
|
// );
|
|
func XGetCurrentDirectoryW(t *TLS, nBufferLength uint32, lpBuffer uintptr) uint32 {
|
|
n, err := syscall.GetCurrentDirectory(nBufferLength, (*uint16)(unsafe.Pointer(lpBuffer)))
|
|
if err != nil {
|
|
t.setErrno(err)
|
|
}
|
|
return n
|
|
}
|
|
|
|
// BOOL GetFileInformationByHandle(
|
|
//
|
|
// HANDLE hFile,
|
|
// LPBY_HANDLE_FILE_INFORMATION lpFileInformation
|
|
//
|
|
// );
|
|
func XGetFileInformationByHandle(t *TLS, hFile, lpFileInformation uintptr) int32 {
|
|
r1, _, e1 := syscall.Syscall(procGetFileInformationByHandle.Addr(), 2, hFile, lpFileInformation, 0)
|
|
if r1 == 0 {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
}
|
|
return int32(r1)
|
|
}
|
|
|
|
// BOOL GetVolumeInformationW(
|
|
//
|
|
// LPCWSTR lpRootPathName,
|
|
// LPWSTR lpVolumeNameBuffer,
|
|
// DWORD nVolumeNameSize,
|
|
// LPDWORD lpVolumeSerialNumber,
|
|
// LPDWORD lpMaximumComponentLength,
|
|
// LPDWORD lpFileSystemFlags,
|
|
// LPWSTR lpFileSystemNameBuffer,
|
|
// DWORD nFileSystemNameSize
|
|
//
|
|
// );
|
|
func XGetVolumeInformationW(t *TLS, lpRootPathName, lpVolumeNameBuffer uintptr, nVolumeNameSize uint32, lpVolumeSerialNumber, lpMaximumComponentLength, lpFileSystemFlags, lpFileSystemNameBuffer uintptr, nFileSystemNameSize uint32) int32 {
|
|
r0, _, err := syscall.Syscall9(procGetVolumeInformationW.Addr(), 8,
|
|
lpRootPathName,
|
|
lpVolumeNameBuffer,
|
|
uintptr(nVolumeNameSize),
|
|
lpVolumeSerialNumber,
|
|
lpMaximumComponentLength,
|
|
lpFileSystemFlags,
|
|
lpFileSystemNameBuffer,
|
|
uintptr(nFileSystemNameSize),
|
|
0,
|
|
)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// wchar_t *wcschr(
|
|
//
|
|
// const wchar_t *str,
|
|
// wchar_t c
|
|
//
|
|
// );
|
|
func Xwcschr(t *TLS, str uintptr, c wchar_t) uintptr {
|
|
var source = str
|
|
for {
|
|
var buf = *(*uint16)(unsafe.Pointer(source))
|
|
if buf == 0 {
|
|
return 0
|
|
}
|
|
if buf == c {
|
|
return source
|
|
}
|
|
// wchar_t = 2 bytes
|
|
source++
|
|
source++
|
|
}
|
|
}
|
|
|
|
// BOOL SetFileTime(
|
|
//
|
|
// HANDLE hFile,
|
|
// const FILETIME *lpCreationTime,
|
|
// const FILETIME *lpLastAccessTime,
|
|
// const FILETIME *lpLastWriteTime
|
|
//
|
|
// );
|
|
func XSetFileTime(t *TLS, hFile uintptr, lpCreationTime, lpLastAccessTime, lpLastWriteTime uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// DWORD GetNamedSecurityInfoW(
|
|
//
|
|
// LPCWSTR pObjectName,
|
|
// SE_OBJECT_TYPE ObjectType,
|
|
// SECURITY_INFORMATION SecurityInfo,
|
|
// PSID *ppsidOwner,
|
|
// PSID *ppsidGroup,
|
|
// PACL *ppDacl,
|
|
// PACL *ppSacl,
|
|
// PSECURITY_DESCRIPTOR *ppSecurityDescriptor
|
|
//
|
|
// );
|
|
func XGetNamedSecurityInfoW(t *TLS, pObjectName uintptr, ObjectType, SecurityInfo uint32, ppsidOwner, ppsidGroup, ppDacl, ppSacl, ppSecurityDescriptor uintptr) uint32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// BOOL OpenProcessToken(
|
|
//
|
|
// HANDLE ProcessHandle,
|
|
// DWORD DesiredAccess,
|
|
// PHANDLE TokenHandle
|
|
//
|
|
// );
|
|
func XOpenProcessToken(t *TLS, ProcessHandle uintptr, DesiredAccess uint32, TokenHandle uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// BOOL GetTokenInformation(
|
|
//
|
|
// HANDLE TokenHandle,
|
|
// TOKEN_INFORMATION_CLASS TokenInformationClass,
|
|
// LPVOID TokenInformation,
|
|
// DWORD TokenInformationLength,
|
|
// PDWORD ReturnLength
|
|
//
|
|
// );
|
|
func XGetTokenInformation(t *TLS, TokenHandle uintptr, TokenInformationClass uint32, TokenInformation uintptr, TokenInformationLength uint32, ReturnLength uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// BOOL EqualSid(
|
|
//
|
|
// PSID pSid1,
|
|
// PSID pSid2
|
|
//
|
|
// );
|
|
func XEqualSid(t *TLS, pSid1, pSid2 uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int WSAStartup(
|
|
//
|
|
// WORD wVersionRequired,
|
|
// LPWSADATA lpWSAData
|
|
//
|
|
// );
|
|
func XWSAStartup(t *TLS, wVersionRequired uint16, lpWSAData uintptr) int32 {
|
|
r0, _, _ := syscall.Syscall(procWSAStartup.Addr(), 2, uintptr(wVersionRequired), lpWSAData, 0)
|
|
if r0 != 0 {
|
|
t.setErrno(r0)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// HMODULE GetModuleHandleA(LPCSTR lpModuleName);
|
|
func XGetModuleHandleA(t *TLS, lpModuleName uintptr) uintptr {
|
|
r0, _, err := syscall.Syscall(procGetModuleHandleA.Addr(), 1, lpModuleName, 0, 0)
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// HMODULE GetModuleHandleW(
|
|
//
|
|
// LPCWSTR lpModuleName
|
|
//
|
|
// );
|
|
func XGetModuleHandleW(t *TLS, lpModuleName uintptr) uintptr {
|
|
r0, _, err := syscall.Syscall(procGetModuleHandleW.Addr(), 1, lpModuleName, 0, 0)
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// DWORD GetEnvironmentVariableW(
|
|
//
|
|
// LPCWSTR lpName,
|
|
// LPWSTR lpBuffer,
|
|
// DWORD nSize
|
|
//
|
|
// );
|
|
func XGetEnvironmentVariableW(t *TLS, lpName, lpBuffer uintptr, nSize uint32) uint32 {
|
|
r0, _, e1 := syscall.Syscall(procGetEnvironmentVariableW.Addr(), 3, lpName, lpBuffer, uintptr(nSize))
|
|
n := uint32(r0)
|
|
if n == 0 {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
// int lstrcmpiA(
|
|
//
|
|
// LPCSTR lpString1,
|
|
// LPCSTR lpString2
|
|
//
|
|
// );
|
|
func XlstrcmpiA(t *TLS, lpString1, lpString2 uintptr) int32 {
|
|
var s1 = strings.ToLower(GoString(lpString1))
|
|
var s2 = strings.ToLower(GoString(lpString2))
|
|
return int32(strings.Compare(s1, s2))
|
|
}
|
|
|
|
func XGetModuleFileNameA(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// UINT GetACP();
|
|
func XGetACP(t *TLS) uint32 {
|
|
r0, _, _ := syscall.Syscall(procGetACP.Addr(), 0, 0, 0, 0)
|
|
return uint32(r0)
|
|
}
|
|
|
|
// BOOL GetUserNameW(
|
|
//
|
|
// LPWSTR lpBuffer,
|
|
// LPDWORD pcbBuffer
|
|
//
|
|
// );
|
|
func XGetUserNameW(t *TLS, lpBuffer, pcbBuffer uintptr) int32 {
|
|
u, err := user.Current()
|
|
if err != nil {
|
|
panic(todo(""))
|
|
return 0
|
|
}
|
|
|
|
wcnt := *(*uint16)(unsafe.Pointer(pcbBuffer))
|
|
s := utf16.Encode([]rune(u.Username))
|
|
if len(s)+1 > int(wcnt) {
|
|
panic(todo(""))
|
|
}
|
|
|
|
*(*uint16)(unsafe.Pointer(pcbBuffer)) = uint16(len(s) + 1)
|
|
for _, v := range s {
|
|
*(*uint16)(unsafe.Pointer(lpBuffer)) = v
|
|
lpBuffer += 2
|
|
}
|
|
return 1
|
|
}
|
|
|
|
// HMODULE LoadLibraryExW(
|
|
//
|
|
// LPCWSTR lpLibFileName,
|
|
// HANDLE hFile,
|
|
// DWORD dwFlags
|
|
//
|
|
// );
|
|
func XLoadLibraryExW(t *TLS, lpLibFileName, hFile uintptr, dwFlags uint32) uintptr {
|
|
return 0 // If the function fails, the return value is NULL.
|
|
}
|
|
|
|
// wchar_t *wcscpy(
|
|
//
|
|
// wchar_t *strDestination,
|
|
// const wchar_t *strSource
|
|
//
|
|
// );
|
|
func Xwcscpy(t *TLS, strDestination, strSource uintptr) uintptr {
|
|
if strSource == 0 {
|
|
return 0
|
|
}
|
|
|
|
d := strDestination
|
|
for {
|
|
c := *(*uint16)(unsafe.Pointer(strSource))
|
|
strSource += 2
|
|
*(*uint16)(unsafe.Pointer(d)) = c
|
|
d += 2
|
|
if c == 0 {
|
|
return strDestination
|
|
}
|
|
}
|
|
}
|
|
|
|
func XwsprintfW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// ATOM RegisterClassW(
|
|
//
|
|
// const WNDCLASSW *lpWndClass
|
|
//
|
|
// );
|
|
func XRegisterClassW(t *TLS, lpWndClass uintptr) int32 {
|
|
r0, _, err := syscall.Syscall(procRegisterClassW.Addr(), 1, lpWndClass, 0, 0)
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
func XKillTimer(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XDestroyWindow(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// BOOL UnregisterClassW(
|
|
//
|
|
// LPCWSTR lpClassName,
|
|
// HINSTANCE hInstance
|
|
//
|
|
// );
|
|
func XUnregisterClassW(t *TLS, lpClassName, hInstance uintptr) int32 {
|
|
r0, _, err := syscall.Syscall(procUnregisterClassW.Addr(), 2, lpClassName, hInstance, 0)
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
func XPostMessageW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XSetTimer(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// HWND CreateWindowExW(
|
|
//
|
|
// DWORD dwExStyle,
|
|
// LPCWSTR lpClassName,
|
|
// LPCWSTR lpWindowName,
|
|
// DWORD dwStyle,
|
|
// int X,
|
|
// int Y,
|
|
// int nWidth,
|
|
// int nHeight,
|
|
// HWND hWndParent,
|
|
// HMENU hMenu,
|
|
// HINSTANCE hInstance,
|
|
// LPVOID lpParam
|
|
//
|
|
// );
|
|
func XCreateWindowExW(t *TLS, dwExStyle uint32, lpClassName, lpWindowName uintptr, dwStyle uint32, x, y, nWidth, nHeight int32, hWndParent, hMenu, hInstance, lpParam uintptr) uintptr {
|
|
r0, _, err := syscall.Syscall12(procCreateWindowExW.Addr(), 12,
|
|
uintptr(dwExStyle),
|
|
lpClassName,
|
|
lpWindowName,
|
|
uintptr(dwStyle),
|
|
uintptr(x),
|
|
uintptr(y),
|
|
uintptr(nWidth),
|
|
uintptr(nHeight),
|
|
hWndParent,
|
|
hMenu,
|
|
hInstance,
|
|
lpParam,
|
|
)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// BOOL PeekMessageW(
|
|
//
|
|
// LPMSG lpMsg,
|
|
// HWND hWnd,
|
|
// UINT wMsgFilterMin,
|
|
// UINT wMsgFilterMax,
|
|
// UINT wRemoveMsg
|
|
//
|
|
// );
|
|
func XPeekMessageW(t *TLS, lpMsg, hWnd uintptr, wMsgFilterMin, wMsgFilterMax, wRemoveMsg uint32) int32 {
|
|
r0, _, err := syscall.Syscall6(procPeekMessageW.Addr(), 5,
|
|
lpMsg,
|
|
hWnd,
|
|
uintptr(wMsgFilterMin),
|
|
uintptr(wMsgFilterMax),
|
|
uintptr(wRemoveMsg),
|
|
0,
|
|
)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
func XGetMessageW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XPostQuitMessage(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XTranslateMessage(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XDispatchMessageW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// DWORD SleepEx(
|
|
//
|
|
// DWORD dwMilliseconds,
|
|
// BOOL bAlertable
|
|
//
|
|
// );
|
|
func XSleepEx(t *TLS, dwMilliseconds uint32, bAlertable int32) uint32 {
|
|
r0, _, _ := syscall.Syscall(procSleepEx.Addr(), 2, uintptr(dwMilliseconds), uintptr(bAlertable), 0)
|
|
return uint32(r0)
|
|
}
|
|
|
|
// BOOL CreatePipe(
|
|
//
|
|
// PHANDLE hReadPipe,
|
|
// PHANDLE hWritePipe,
|
|
// LPSECURITY_ATTRIBUTES lpPipeAttributes,
|
|
// DWORD nSize
|
|
//
|
|
// );
|
|
func XCreatePipe(t *TLS, hReadPipe, hWritePipe, lpPipeAttributes uintptr, nSize uint32) int32 {
|
|
r0, _, err := syscall.Syscall6(procCreatePipe.Addr(), 4, hReadPipe, hWritePipe, lpPipeAttributes, uintptr(nSize), 0, 0)
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// BOOL CreateProcessW(
|
|
//
|
|
// LPCWSTR lpApplicationName,
|
|
// LPWSTR lpCommandLine,
|
|
// LPSECURITY_ATTRIBUTES lpProcessAttributes,
|
|
// LPSECURITY_ATTRIBUTES lpThreadAttributes,
|
|
// BOOL bInheritHandles,
|
|
// DWORD dwCreationFlags,
|
|
// LPVOID lpEnvironment,
|
|
// LPCWSTR lpCurrentDirectory,
|
|
// LPSTARTUPINFOW lpStartupInfo,
|
|
// LPPROCESS_INFORMATION lpProcessInformation
|
|
//
|
|
// );
|
|
func XCreateProcessW(t *TLS, lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes uintptr, bInheritHandles int32, dwCreationFlags uint32,
|
|
lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation uintptr) int32 {
|
|
|
|
r1, _, e1 := syscall.Syscall12(procCreateProcessW.Addr(), 10, lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes,
|
|
uintptr(bInheritHandles), uintptr(dwCreationFlags), lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation, 0, 0)
|
|
if r1 == 0 {
|
|
if e1 != 0 {
|
|
t.setErrno(e1)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
}
|
|
|
|
return int32(r1)
|
|
}
|
|
|
|
// DWORD WaitForInputIdle(
|
|
//
|
|
// HANDLE hProcess,
|
|
// DWORD dwMilliseconds
|
|
//
|
|
// );
|
|
func XWaitForInputIdle(t *TLS, hProcess uintptr, dwMilliseconds uint32) int32 {
|
|
r0, _, _ := syscall.Syscall(procWaitForInputIdle.Addr(), 2, hProcess, uintptr(dwMilliseconds), 0)
|
|
return int32(r0)
|
|
}
|
|
|
|
// DWORD SearchPathW(
|
|
//
|
|
// LPCWSTR lpPath,
|
|
// LPCWSTR lpFileName,
|
|
// LPCWSTR lpExtension,
|
|
// DWORD nBufferLength,
|
|
// LPWSTR lpBuffer,
|
|
// LPWSTR *lpFilePart
|
|
//
|
|
// );
|
|
func XSearchPathW(t *TLS, lpPath, lpFileName, lpExtension uintptr, nBufferLength uint32, lpBuffer, lpFilePart uintptr) int32 {
|
|
r0, _, err := syscall.Syscall6(procSearchPathW.Addr(), 6, lpPath, lpFileName, lpExtension, uintptr(nBufferLength), lpBuffer, lpFilePart)
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
func XGetShortPathNameW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// BOOL GetExitCodeProcess(
|
|
//
|
|
// HANDLE hProcess,
|
|
// LPDWORD lpExitCode
|
|
//
|
|
// );
|
|
func XGetExitCodeProcess(t *TLS, hProcess, lpExitCode uintptr) int32 {
|
|
r0, _, err := syscall.Syscall(procGetExitCodeProcess.Addr(), 2, hProcess, lpExitCode, 0)
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// BOOL PeekNamedPipe(
|
|
//
|
|
// HANDLE hNamedPipe,
|
|
// LPVOID lpBuffer,
|
|
// DWORD nBufferSize,
|
|
// LPDWORD lpBytesRead,
|
|
// LPDWORD lpTotalBytesAvail,
|
|
// LPDWORD lpBytesLeftThisMessage
|
|
//
|
|
// );
|
|
func XPeekNamedPipe(t *TLS, hNamedPipe, lpBuffer uintptr, nBufferSize uint32, lpBytesRead, lpTotalBytesAvail, lpBytesLeftThisMessage uintptr) int32 {
|
|
r0, _, err := syscall.Syscall6(procPeekNamedPipe.Addr(), 6, hNamedPipe, lpBuffer, uintptr(nBufferSize), lpBytesRead, lpTotalBytesAvail, lpBytesLeftThisMessage)
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// long _InterlockedExchange(
|
|
//
|
|
// long volatile * Target,
|
|
// long Value
|
|
//
|
|
// );
|
|
func X_InterlockedExchange(t *TLS, Target uintptr, Value long) long {
|
|
old := atomic.SwapInt32((*int32)(unsafe.Pointer(Target)), Value)
|
|
return old
|
|
}
|
|
|
|
// BOOL TerminateThread(
|
|
//
|
|
// [in, out] HANDLE hThread,
|
|
// [in] DWORD dwExitCode
|
|
//
|
|
// );
|
|
func XTerminateThread(t *TLS, hThread uintptr, dwExitCode uint32) int32 {
|
|
r0, _, err := syscall.Syscall(procTerminateThread.Addr(), 2, hThread, uintptr(dwExitCode), 0)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// BOOL GetComputerNameW(
|
|
//
|
|
// LPWSTR lpBuffer,
|
|
// LPDWORD nSize
|
|
//
|
|
// );
|
|
func XGetComputerNameW(t *TLS, lpBuffer, nSize uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func Xgethostname(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XSendMessageW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XWSAGetLastError(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func Xclosesocket(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XWspiapiFreeAddrInfo(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XWspiapiGetNameInfo(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XIN6_ADDR_EQUAL(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func X__ccgo_in6addr_anyp(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XIN6_IS_ADDR_V4MAPPED(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XSetHandleInformation(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func Xioctlsocket(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XGetWindowLongPtrW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XSetWindowLongPtrW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XWSAAsyncSelect(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func Xinet_ntoa(t *TLS, _ ...interface{}) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func X_controlfp(t *TLS, _ ...interface{}) uint32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// BOOL QueryPerformanceFrequency(
|
|
//
|
|
// LARGE_INTEGER *lpFrequency
|
|
//
|
|
// );
|
|
func XQueryPerformanceFrequency(t *TLS, lpFrequency uintptr) int32 {
|
|
|
|
r1, _, err := syscall.Syscall(procQueryPerformanceFrequency.Addr(), 1, lpFrequency, 0, 0)
|
|
if r1 == 0 {
|
|
t.setErrno(err)
|
|
return 0
|
|
}
|
|
return int32(r1)
|
|
}
|
|
|
|
func inDST(t gotime.Time) bool {
|
|
|
|
jan1st := gotime.Date(t.Year(), 1, 1, 0, 0, 0, 0, t.Location()) // January 1st is always outside DST window
|
|
|
|
_, off1 := t.Zone()
|
|
_, off2 := jan1st.Zone()
|
|
|
|
return off1 != off2
|
|
}
|
|
|
|
// void _ftime( struct _timeb *timeptr );
|
|
func X_ftime(t *TLS, timeptr uintptr) {
|
|
var tm = gotime.Now()
|
|
var tPtr = (*time.X__timeb64)(unsafe.Pointer(timeptr))
|
|
tPtr.Ftime = tm.Unix()
|
|
tPtr.Fmillitm = uint16(gotime.Duration(tm.Nanosecond()) / gotime.Millisecond)
|
|
if inDST(tm) {
|
|
tPtr.Fdstflag = 1
|
|
}
|
|
_, offset := tm.Zone()
|
|
tPtr.Ftimezone = int16(offset)
|
|
}
|
|
|
|
func Xgmtime(t *TLS, _ ...interface{}) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XDdeInitializeW(t *TLS, _ ...interface{}) uint32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XDdeCreateStringHandleW(t *TLS, _ ...interface{}) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XDdeNameService(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func X_snwprintf(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XDdeQueryStringW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int _wcsicmp(
|
|
//
|
|
// const wchar_t *string1,
|
|
// const wchar_t *string2
|
|
//
|
|
// );
|
|
func X_wcsicmp(t *TLS, string1, string2 uintptr) int32 {
|
|
return Xwcsicmp(t, string1, string2)
|
|
}
|
|
|
|
func XDdeCreateDataHandle(t *TLS, _ ...interface{}) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XDdeAccessData(t *TLS, _ ...interface{}) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XDdeUnaccessData(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XDdeUninitialize(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XDdeConnect(t *TLS, _ ...interface{}) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XDdeFreeStringHandle(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XRegisterClassExW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XGlobalGetAtomNameW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XGlobalAddAtomW(t *TLS, _ ...interface{}) uint16 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XEnumWindows(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XIsWindow(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XGlobalDeleteAtom(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XDdeGetLastError(t *TLS, _ ...interface{}) uint32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// HDDEDATA DdeClientTransaction(
|
|
//
|
|
// LPBYTE pData,
|
|
// DWORD cbData,
|
|
// HCONV hConv,
|
|
// HSZ hszItem,
|
|
// UINT wFmt,
|
|
// UINT wType,
|
|
// DWORD dwTimeout,
|
|
// LPDWORD pdwResult
|
|
//
|
|
// );
|
|
func XDdeClientTransaction(t *TLS, pData uintptr, cbData uint32, hConv uintptr, hszItem uintptr, wFmt, wType, dwTimeout uint32, pdwResult uintptr) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XDdeAbandonTransaction(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XDdeFreeDataHandle(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XDdeGetData(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XDdeDisconnect(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XRegCloseKey(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XRegDeleteValueW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XRegEnumKeyExW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XRegQueryValueExW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XRegEnumValueW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XRegConnectRegistryW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XRegCreateKeyExW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XRegOpenKeyExW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XRegDeleteKeyW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func XRegSetValueExW(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int _vsnwprintf(
|
|
//
|
|
// wchar_t *buffer,
|
|
// size_t count,
|
|
// const wchar_t *format,
|
|
// va_list argptr
|
|
//
|
|
// );
|
|
func X__mingw_vsnwprintf(t *TLS, buffer uintptr, count types.Size_t, format, va uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int vprintf(const char *format, va_list ap);
|
|
func X__mingw_vprintf(t *TLS, s, ap uintptr) int32 { return Xvprintf(t, s, ap) }
|
|
|
|
// int vfscanf(FILE * restrict stream, const char * restrict format, va_list arg);
|
|
func X__mingw_vfscanf(t *TLS, stream, format, ap uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int vsscanf(const char *str, const char *format, va_list ap);
|
|
func X__mingw_vsscanf(t *TLS, str, format, ap uintptr) int32 {
|
|
return Xsscanf(t, str, format, ap)
|
|
}
|
|
|
|
// int vfprintf(FILE * restrict stream, const char * restrict format, va_list arg);
|
|
func X__mingw_vfprintf(t *TLS, f uintptr, format, va uintptr) int32 {
|
|
return Xvfprintf(t, f, format, va)
|
|
}
|
|
|
|
// int vsprintf(char * restrict s, const char * restrict format, va_list arg);
|
|
func X__mingw_vsprintf(t *TLS, s, format, ap uintptr) int32 {
|
|
return Xvsprintf(t, s, format, ap)
|
|
}
|
|
|
|
// int vsnprintf(char *str, size_t size, const char *format, va_list ap);
|
|
func X__mingw_vsnprintf(t *TLS, str uintptr, size types.Size_t, format, ap uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int putchar(int char)
|
|
func X_putchar(t *TLS, c int32) int32 {
|
|
if _, err := fwrite(unistd.STDOUT_FILENO, []byte{byte(c)}); err != nil {
|
|
return -1
|
|
}
|
|
return int32(byte(c))
|
|
}
|
|
|
|
// int vfwscanf(FILE *stream, const wchar_t *format, va_list argptr;);
|
|
func X__mingw_vfwscanf(t *TLS, stream uintptr, format, ap uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int vswscanf(const wchar_t *buffer, const wchar_t *format, va_list arglist);
|
|
func X__mingw_vswscanf(t *TLS, stream uintptr, format, ap uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int vfwprintf(FILE * restrict stream, const wchar_t * restrict format, va_list arg);
|
|
func X__mingw_vfwprintf(t *TLS, stream, format, ap uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int putchar(int c);
|
|
func Xputchar(t *TLS, c int32) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// void _assert(
|
|
//
|
|
// char const* message,
|
|
// char const* filename,
|
|
// unsigned line
|
|
//
|
|
// );
|
|
func X_assert(t *TLS, message, filename uintptr, line uint32) {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// char *strdup(const char *s);
|
|
func X_strdup(t *TLS, s uintptr) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int _access(
|
|
//
|
|
// const char *path,
|
|
// int mode
|
|
//
|
|
// );
|
|
func X_access(t *TLS, pathname uintptr, mode int32) int32 {
|
|
|
|
var path = GoString(pathname)
|
|
|
|
info, err := os.Stat(path)
|
|
if err != nil {
|
|
// doesn't exist
|
|
return errno.ENOENT
|
|
}
|
|
|
|
switch mode {
|
|
case 0:
|
|
// exists
|
|
return 0
|
|
case 2:
|
|
// write-only
|
|
// Check if the user bit is enabled in file permission
|
|
if info.Mode().Perm()&(1<<(uint(7))) == 1 {
|
|
// write-able
|
|
return 0
|
|
}
|
|
case 4:
|
|
// read-only
|
|
// Check if the user bit is enabled in file permission
|
|
if info.Mode().Perm()&(1<<(uint(7))) == 0 {
|
|
// not set, so read-only
|
|
return 0
|
|
}
|
|
case 6:
|
|
// r/w
|
|
if info.Mode().Perm()&(1<<(uint(7))) == 1 {
|
|
// write-able
|
|
return 0
|
|
}
|
|
}
|
|
|
|
return errno.EACCES
|
|
|
|
}
|
|
|
|
// BOOL WINAPI SetConsoleCtrlHandler(
|
|
//
|
|
// _In_opt_ PHANDLER_ROUTINE HandlerRoutine,
|
|
// _In_ BOOL Add
|
|
//
|
|
// );
|
|
func XSetConsoleCtrlHandler(t *TLS, HandlerRoutine uintptr, Add int32) int32 {
|
|
|
|
//var fcc = &struct {
|
|
// f func(*TLS, uint32) int32
|
|
//}{}
|
|
//fcc = (*struct{ f func(*TLS, uint32) int32 })(unsafe.Pointer(HandlerRoutine))
|
|
//var hdlr = fcc.f
|
|
//
|
|
//_, _, err := procSetConsoleCtrlHandler.Call(
|
|
//syscall.NewCallback(func(controlType uint) uint {
|
|
// return uint( hdlr(t, uint32(controlType)) )
|
|
// }), 1)
|
|
//
|
|
//if err != nil {
|
|
// panic("failed: SetConsoleCtrlHandler")
|
|
//}
|
|
|
|
return 0
|
|
}
|
|
|
|
// DebugBreak
|
|
func XDebugBreak(t *TLS) {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int _isatty( int fd );
|
|
func X_isatty(t *TLS, fd int32) int32 {
|
|
|
|
f, ok := fdToFile(fd)
|
|
if !ok {
|
|
t.setErrno(errno.EBADF)
|
|
return 0
|
|
}
|
|
|
|
if fd == unistd.STDOUT_FILENO ||
|
|
fd == unistd.STDIN_FILENO ||
|
|
fd == unistd.STDERR_FILENO {
|
|
var mode uint32
|
|
err := syscall.GetConsoleMode(f.Handle, &mode)
|
|
if err != nil {
|
|
t.setErrno(errno.EINVAL)
|
|
return 0
|
|
}
|
|
// is console
|
|
return 1
|
|
}
|
|
|
|
return 0
|
|
}
|
|
|
|
// BOOL WINAPI SetConsoleTextAttribute(
|
|
//
|
|
// _In_ HANDLE hConsoleOutput,
|
|
// _In_ WORD wAttributes
|
|
//
|
|
// );
|
|
func XSetConsoleTextAttribute(t *TLS, hConsoleOutput uintptr, wAttributes uint16) int32 {
|
|
r1, _, _ := syscall.Syscall(procSetConsoleTextAttribute.Addr(), 2, hConsoleOutput, uintptr(wAttributes), 0)
|
|
return int32(r1)
|
|
}
|
|
|
|
// BOOL WINAPI GetConsoleScreenBufferInfo(
|
|
//
|
|
// _In_ HANDLE hConsoleOutput,
|
|
// _Out_ PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo
|
|
//
|
|
// );
|
|
func XGetConsoleScreenBufferInfo(t *TLS, hConsoleOutput, lpConsoleScreenBufferInfo uintptr) int32 {
|
|
r1, _, _ := syscall.Syscall(procGetConsoleScreenBufferInfo.Addr(), 2, hConsoleOutput, lpConsoleScreenBufferInfo, 0)
|
|
return int32(r1)
|
|
}
|
|
|
|
// FILE *_popen(
|
|
//
|
|
// const char *command,
|
|
// const char *mode
|
|
//
|
|
// );
|
|
func X_popen(t *TLS, command, mode uintptr) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int _wunlink(
|
|
//
|
|
// const wchar_t *filename
|
|
//
|
|
// );
|
|
func X_wunlink(t *TLS, filename uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func Xclosedir(tls *TLS, dir uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func Xopendir(tls *TLS, name uintptr) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func Xreaddir(tls *TLS, dir uintptr) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int _unlink(
|
|
//
|
|
// const char *filename
|
|
//
|
|
// );
|
|
func X_unlink(t *TLS, filename uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int pclose(FILE *stream);
|
|
func X_pclose(t *TLS, stream uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int setmode (int fd, int mode);
|
|
func Xsetmode(t *TLS, fd, mode int32) int32 {
|
|
return X_setmode(t, fd, mode)
|
|
}
|
|
|
|
// int _setmode (int fd, int mode);
|
|
func X_setmode(t *TLS, fd, mode int32) int32 {
|
|
|
|
_, ok := fdToFile(fd)
|
|
if !ok {
|
|
t.setErrno(errno.EBADF)
|
|
return -1
|
|
}
|
|
|
|
// we're always in binary mode.
|
|
// at least for now.
|
|
|
|
if mode == fcntl.O_BINARY {
|
|
return fcntl.O_BINARY
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
return -1
|
|
}
|
|
}
|
|
|
|
// int _mkdir(const char *dirname);
|
|
func X_mkdir(t *TLS, dirname uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int _chmod( const char *filename, int pmode );
|
|
func X_chmod(t *TLS, filename uintptr, pmode int32) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int _fileno(FILE *stream);
|
|
func X_fileno(t *TLS, stream uintptr) int32 {
|
|
f, ok := winGetObject(stream).(*file)
|
|
if !ok {
|
|
t.setErrno(errno.EBADF)
|
|
return -1
|
|
}
|
|
return f._fd
|
|
}
|
|
|
|
// void rewind(FILE *stream);
|
|
func Xrewind(t *TLS, stream uintptr) {
|
|
Xfseek(t, stream, 0, unistd.SEEK_SET)
|
|
}
|
|
|
|
// __atomic_load_n
|
|
func X__atomic_load_n(t *TLS) {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// __atomic_store_n
|
|
func X__atomic_store_n(t *TLS, _ ...interface{}) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// __builtin_add_overflow
|
|
func X__builtin_add_overflow(t *TLS) {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// __builtin_mul_overflow
|
|
func X__builtin_mul_overflow(t *TLS) {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// __builtin_sub_overflow
|
|
func X__builtin_sub_overflow(t *TLS) {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func goWideBytes(p uintptr, n int) []uint16 {
|
|
b := GoBytes(p, 2*n)
|
|
var w []uint16
|
|
for i := 0; i < len(b); i += 2 {
|
|
w = append(w, *(*uint16)(unsafe.Pointer(&b[i])))
|
|
}
|
|
return w
|
|
}
|
|
|
|
// This version does include the zero terminator in the returned Go string.
|
|
func goWideString(p uintptr) string {
|
|
if p == 0 {
|
|
return ""
|
|
}
|
|
var w []uint16
|
|
var raw = (*RawMem)(unsafe.Pointer(p))
|
|
var i = 0
|
|
for {
|
|
wc := *(*uint16)(unsafe.Pointer(&raw[i]))
|
|
w = append(w, wc)
|
|
// append until U0000
|
|
if wc == 0 {
|
|
break
|
|
}
|
|
i = i + 2
|
|
}
|
|
s := utf16.Decode(w)
|
|
return string(s)
|
|
}
|
|
|
|
func goWideStringN(p uintptr, n int) string {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// This version does not include the zero terminator in the returned Go string.
|
|
func goWideStringNZ(p uintptr) string {
|
|
if p == 0 {
|
|
return ""
|
|
}
|
|
|
|
var w []uint16
|
|
var raw = (*RawMem)(unsafe.Pointer(p))
|
|
var i = 0
|
|
for {
|
|
wc := *(*uint16)(unsafe.Pointer(&raw[i]))
|
|
if wc == 0 {
|
|
break
|
|
}
|
|
|
|
w = append(w, wc)
|
|
i = i + 2
|
|
}
|
|
s := utf16.Decode(w)
|
|
return string(s)
|
|
}
|
|
|
|
// LPWSTR GetCommandLineW();
|
|
func XGetCommandLineW(t *TLS) uintptr {
|
|
return uintptr(unsafe.Pointer(syscall.GetCommandLine()))
|
|
}
|
|
|
|
// BOOL AddAccessDeniedAce(
|
|
//
|
|
// PACL pAcl,
|
|
// DWORD dwAceRevision,
|
|
// DWORD AccessMask,
|
|
// PSID pSid
|
|
//
|
|
// );
|
|
func XAddAccessDeniedAce(t *TLS, pAcl uintptr, dwAceRevision, AccessMask uint32, pSid uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// BOOL AddAce(
|
|
//
|
|
// PACL pAcl,
|
|
// DWORD dwAceRevision,
|
|
// DWORD dwStartingAceIndex,
|
|
// LPVOID pAceList,
|
|
// DWORD nAceListLength
|
|
//
|
|
// );
|
|
func XAddAce(t *TLS, pAcl uintptr, dwAceRevision, dwStartingAceIndex uint32, pAceList uintptr, nAceListLength uint32) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// BOOL GetAce(
|
|
//
|
|
// PACL pAcl,
|
|
// DWORD dwAceIndex,
|
|
// LPVOID *pAce
|
|
//
|
|
// );
|
|
func XGetAce(t *TLS, pAcl uintptr, dwAceIndex uint32, pAce uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// BOOL GetAclInformation(
|
|
//
|
|
// PACL pAcl,
|
|
// LPVOID pAclInformation,
|
|
// DWORD nAclInformationLength,
|
|
// ACL_INFORMATION_CLASS dwAclInformationClass
|
|
//
|
|
// );
|
|
func XGetAclInformation(t *TLS, pAcl, pAclInformation uintptr, nAclInformationLength, dwAclInformationClass uint32) int32 {
|
|
r0, _, err := syscall.Syscall6(procGetAclInformation.Addr(), 4,
|
|
pAclInformation,
|
|
pAclInformation,
|
|
uintptr(nAclInformationLength),
|
|
uintptr(dwAclInformationClass),
|
|
0,
|
|
0,
|
|
)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// BOOL GetFileSecurityA(
|
|
//
|
|
// LPCSTR lpFileName,
|
|
// SECURITY_INFORMATION RequestedInformation,
|
|
// PSECURITY_DESCRIPTOR pSecurityDescriptor,
|
|
// DWORD nLength,
|
|
// LPDWORD lpnLengthNeeded
|
|
//
|
|
// );
|
|
func XGetFileSecurityA(t *TLS, lpFileName uintptr, RequestedInformation uint32, pSecurityDescriptor uintptr, nLength uint32, lpnLengthNeeded uintptr) int32 {
|
|
r0, _, err := syscall.Syscall6(procGetFileSecurityA.Addr(), 5,
|
|
lpFileName,
|
|
uintptr(RequestedInformation),
|
|
pSecurityDescriptor,
|
|
uintptr(nLength),
|
|
lpnLengthNeeded,
|
|
0,
|
|
)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// DWORD GetLengthSid(
|
|
//
|
|
// PSID pSid
|
|
//
|
|
// );
|
|
func XGetLengthSid(t *TLS, pSid uintptr) uint32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// BOOL GetSecurityDescriptorDacl(
|
|
//
|
|
// PSECURITY_DESCRIPTOR pSecurityDescriptor,
|
|
// LPBOOL lpbDaclPresent,
|
|
// PACL *pDacl,
|
|
// LPBOOL lpbDaclDefaulted
|
|
//
|
|
// );
|
|
func XGetSecurityDescriptorDacl(t *TLS, pSecurityDescriptor, lpbDaclPresent, pDacl, lpbDaclDefaulted uintptr) int32 {
|
|
r0, _, err := syscall.Syscall6(procGetSecurityDescriptorDacl.Addr(), 4,
|
|
pSecurityDescriptor,
|
|
lpbDaclPresent,
|
|
pDacl,
|
|
lpbDaclDefaulted,
|
|
0,
|
|
0,
|
|
)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// DWORD GetSidLengthRequired(
|
|
//
|
|
// UCHAR nSubAuthorityCount
|
|
//
|
|
// );
|
|
func XGetSidLengthRequired(t *TLS, nSubAuthorityCount uint8) int32 {
|
|
r0, _, err := syscall.Syscall(procGetSidLengthRequired.Addr(), 1, uintptr(nSubAuthorityCount), 0, 0)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// PDWORD GetSidSubAuthority(
|
|
//
|
|
// PSID pSid,
|
|
// DWORD nSubAuthority
|
|
//
|
|
// );
|
|
func XGetSidSubAuthority(t *TLS, pSid uintptr, nSubAuthority uint32) uintptr {
|
|
r0, _, err := syscall.Syscall(procGetSidSubAuthority.Addr(), 2, pSid, uintptr(nSubAuthority), 0)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// BOOL InitializeAcl(
|
|
//
|
|
// PACL pAcl,
|
|
// DWORD nAclLength,
|
|
// DWORD dwAclRevision
|
|
//
|
|
// );
|
|
func XInitializeAcl(t *TLS, pAcl uintptr, nAclLength, dwAclRevision uint32) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// BOOL InitializeSid(
|
|
//
|
|
// PSID Sid,
|
|
// PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
|
|
// BYTE nSubAuthorityCount
|
|
//
|
|
// );
|
|
func XInitializeSid(t *TLS, Sid, pIdentifierAuthority uintptr, nSubAuthorityCount uint8) int32 {
|
|
r0, _, err := syscall.Syscall(procInitializeSid.Addr(), 3, Sid, pIdentifierAuthority, uintptr(nSubAuthorityCount))
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// VOID RaiseException(
|
|
//
|
|
// DWORD dwExceptionCode,
|
|
// DWORD dwExceptionFlags,
|
|
// DWORD nNumberOfArguments,
|
|
// const ULONG_PTR *lpArguments
|
|
//
|
|
// );
|
|
func XRaiseException(t *TLS, dwExceptionCode, dwExceptionFlags, nNumberOfArguments uint32, lpArguments uintptr) {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// UINT SetErrorMode(
|
|
//
|
|
// UINT uMode
|
|
//
|
|
// );
|
|
func XSetErrorMode(t *TLS, uMode uint32) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// DWORD SetNamedSecurityInfoA(
|
|
//
|
|
// LPSTR pObjectName,
|
|
// SE_OBJECT_TYPE ObjectType,
|
|
// SECURITY_INFORMATION SecurityInfo,
|
|
// PSID psidOwner,
|
|
// PSID psidGroup,
|
|
// PACL pDacl,
|
|
// PACL pSacl
|
|
//
|
|
// );
|
|
func XSetNamedSecurityInfoA(t *TLS, pObjectName uintptr, ObjectType, SecurityInfo uint32, psidOwner, psidGroup, pDacl, pSacl uintptr) uint32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// BOOL CreateProcessA(
|
|
//
|
|
// LPCSTR lpApplicationName,
|
|
// LPSTR lpCommandLine,
|
|
// LPSECURITY_ATTRIBUTES lpProcessAttributes,
|
|
// LPSECURITY_ATTRIBUTES lpThreadAttributes,
|
|
// BOOL bInheritHandles,
|
|
// DWORD dwCreationFlags,
|
|
// LPVOID lpEnvironment,
|
|
// LPCSTR lpCurrentDirectory,
|
|
// LPSTARTUPINFOA lpStartupInfo,
|
|
// LPPROCESS_INFORMATION lpProcessInformation
|
|
//
|
|
// );
|
|
func XCreateProcessA(t *TLS, lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes uintptr, bInheritHandles int32,
|
|
dwCreationFlags uint32, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation uintptr) int32 {
|
|
r1, _, err := syscall.Syscall12(procCreateProcessA.Addr(), 10, lpApplicationName, lpCommandLine, lpProcessAttributes, lpThreadAttributes,
|
|
uintptr(bInheritHandles), uintptr(dwCreationFlags), lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation, 0, 0)
|
|
if r1 == 0 {
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
} else {
|
|
t.setErrno(errno.EINVAL)
|
|
}
|
|
}
|
|
return int32(r1)
|
|
}
|
|
|
|
// unsigned int _set_abort_behavior(
|
|
//
|
|
// unsigned int flags,
|
|
// unsigned int mask
|
|
//
|
|
// );
|
|
func X_set_abort_behavior(t *TLS, _ ...interface{}) uint32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// HANDLE OpenEventA(
|
|
//
|
|
// DWORD dwDesiredAccess,
|
|
// BOOL bInheritHandle,
|
|
// LPCSTR lpName
|
|
//
|
|
// );
|
|
func XOpenEventA(t *TLS, dwDesiredAccess uint32, bInheritHandle uint32, lpName uintptr) uintptr {
|
|
r0, _, err := syscall.Syscall(procOpenEventA.Addr(), 3, uintptr(dwDesiredAccess), uintptr(bInheritHandle), lpName)
|
|
if r0 == 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// size_t _msize(
|
|
//
|
|
// void *memblock
|
|
//
|
|
// );
|
|
func X_msize(t *TLS, memblock uintptr) types.Size_t {
|
|
return types.Size_t(UsableSize(memblock))
|
|
}
|
|
|
|
// unsigned long _byteswap_ulong ( unsigned long val );
|
|
func X_byteswap_ulong(t *TLS, val ulong) ulong {
|
|
return X__builtin_bswap32(t, val)
|
|
}
|
|
|
|
// unsigned __int64 _byteswap_uint64 ( unsigned __int64 val );
|
|
func X_byteswap_uint64(t *TLS, val uint64) uint64 {
|
|
return X__builtin_bswap64(t, val)
|
|
}
|
|
|
|
// int _commit(
|
|
//
|
|
// int fd
|
|
//
|
|
// );
|
|
func X_commit(t *TLS, fd int32) int32 {
|
|
return Xfsync(t, fd)
|
|
}
|
|
|
|
// int _stati64(
|
|
//
|
|
// const char *path,
|
|
// struct _stati64 *buffer
|
|
//
|
|
// );
|
|
func X_stati64(t *TLS, path, buffer uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int _fstati64(
|
|
//
|
|
// int fd,
|
|
// struct _stati64 *buffer
|
|
//
|
|
// );
|
|
func X_fstati64(t *TLS, fd int32, buffer uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// int _findnext32(
|
|
//
|
|
// intptr_t handle,
|
|
// struct _finddata32_t *fileinfo
|
|
//
|
|
// );
|
|
func X_findnext32(t *TLS, handle types.Intptr_t, buffer uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// intptr_t _findfirst32(
|
|
//
|
|
// const char *filespec,
|
|
// struct _finddata32_t *fileinfo
|
|
//
|
|
// );
|
|
func X_findfirst32(t *TLS, filespec, fileinfo uintptr) types.Intptr_t {
|
|
panic(todo(""))
|
|
}
|
|
|
|
/*-
|
|
* Copyright (c) 1990 The Regents of the University of California.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
// long strtol(const char *nptr, char **endptr, int base);
|
|
func Xstrtol(t *TLS, nptr, endptr uintptr, base int32) long {
|
|
|
|
var s uintptr = nptr
|
|
var acc ulong
|
|
var c byte
|
|
var cutoff ulong
|
|
var neg int32
|
|
var any int32
|
|
var cutlim int32
|
|
|
|
/*
|
|
* Skip white space and pick up leading +/- sign if any.
|
|
* If base is 0, allow 0x for hex and 0 for octal, else
|
|
* assume decimal; if base is already 16, allow 0x.
|
|
*/
|
|
for {
|
|
c = *(*byte)(unsafe.Pointer(s))
|
|
PostIncUintptr(&s, 1)
|
|
var sp = strings.TrimSpace(string(c))
|
|
if len(sp) > 0 {
|
|
break
|
|
}
|
|
}
|
|
|
|
if c == '-' {
|
|
neg = 1
|
|
c = *(*byte)(unsafe.Pointer(s))
|
|
PostIncUintptr(&s, 1)
|
|
} else if c == '+' {
|
|
c = *(*byte)(unsafe.Pointer(s))
|
|
PostIncUintptr(&s, 1)
|
|
}
|
|
|
|
sp := *(*byte)(unsafe.Pointer(s))
|
|
|
|
if (base == 0 || base == 16) &&
|
|
c == '0' && (sp == 'x' || sp == 'X') {
|
|
PostIncUintptr(&s, 1)
|
|
c = *(*byte)(unsafe.Pointer(s)) //s[1];
|
|
PostIncUintptr(&s, 1)
|
|
base = 16
|
|
}
|
|
if base == 0 {
|
|
if c == '0' {
|
|
base = 0
|
|
} else {
|
|
base = 10
|
|
}
|
|
}
|
|
/*
|
|
* Compute the cutoff value between legal numbers and illegal
|
|
* numbers. That is the largest legal value, divided by the
|
|
* base. An input number that is greater than this value, if
|
|
* followed by a legal input character, is too big. One that
|
|
* is equal to this value may be valid or not; the limit
|
|
* between valid and invalid numbers is then based on the last
|
|
* digit. For instance, if the range for longs is
|
|
* [-2147483648..2147483647] and the input base is 10,
|
|
* cutoff will be set to 214748364 and cutlim to either
|
|
* 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated
|
|
* a value > 214748364, or equal but the next digit is > 7 (or 8),
|
|
* the number is too big, and we will return a range error.
|
|
*
|
|
* Set any if any `digits' consumed; make it negative to indicate
|
|
* overflow.
|
|
*/
|
|
var ULONG_MAX ulong = 0xFFFFFFFF
|
|
var LONG_MAX long = long(ULONG_MAX >> 1)
|
|
var LONG_MIN long = ^LONG_MAX
|
|
|
|
if neg == 1 {
|
|
cutoff = ulong(-1 * LONG_MIN)
|
|
} else {
|
|
cutoff = ulong(LONG_MAX)
|
|
}
|
|
cutlim = int32(cutoff % ulong(base))
|
|
cutoff = cutoff / ulong(base)
|
|
|
|
acc = 0
|
|
any = 0
|
|
|
|
for {
|
|
var cs = string(c)
|
|
if unicode.IsDigit([]rune(cs)[0]) {
|
|
c -= '0'
|
|
} else if unicode.IsLetter([]rune(cs)[0]) {
|
|
if unicode.IsUpper([]rune(cs)[0]) {
|
|
c -= 'A' - 10
|
|
} else {
|
|
c -= 'a' - 10
|
|
}
|
|
} else {
|
|
break
|
|
}
|
|
|
|
if int32(c) >= base {
|
|
break
|
|
}
|
|
if any < 0 || acc > cutoff || (acc == cutoff && int32(c) > cutlim) {
|
|
any = -1
|
|
|
|
} else {
|
|
any = 1
|
|
acc *= ulong(base)
|
|
acc += ulong(c)
|
|
}
|
|
|
|
c = *(*byte)(unsafe.Pointer(s))
|
|
PostIncUintptr(&s, 1)
|
|
}
|
|
|
|
if any < 0 {
|
|
if neg == 1 {
|
|
acc = ulong(LONG_MIN)
|
|
} else {
|
|
acc = ulong(LONG_MAX)
|
|
}
|
|
t.setErrno(errno.ERANGE)
|
|
} else if neg == 1 {
|
|
acc = -acc
|
|
}
|
|
|
|
if endptr != 0 {
|
|
if any == 1 {
|
|
PostDecUintptr(&s, 1)
|
|
AssignPtrUintptr(endptr, s)
|
|
} else {
|
|
AssignPtrUintptr(endptr, nptr)
|
|
}
|
|
}
|
|
return long(acc)
|
|
}
|
|
|
|
// unsigned long int strtoul(const char *nptr, char **endptr, int base);
|
|
func Xstrtoul(t *TLS, nptr, endptr uintptr, base int32) ulong {
|
|
var s uintptr = nptr
|
|
var acc ulong
|
|
var c byte
|
|
var cutoff ulong
|
|
var neg int32
|
|
var any int32
|
|
var cutlim int32
|
|
|
|
/*
|
|
* Skip white space and pick up leading +/- sign if any.
|
|
* If base is 0, allow 0x for hex and 0 for octal, else
|
|
* assume decimal; if base is already 16, allow 0x.
|
|
*/
|
|
for {
|
|
c = *(*byte)(unsafe.Pointer(s))
|
|
PostIncUintptr(&s, 1)
|
|
var sp = strings.TrimSpace(string(c))
|
|
if len(sp) > 0 {
|
|
break
|
|
}
|
|
}
|
|
|
|
if c == '-' {
|
|
neg = 1
|
|
c = *(*byte)(unsafe.Pointer(s))
|
|
PostIncUintptr(&s, 1)
|
|
} else if c == '+' {
|
|
c = *(*byte)(unsafe.Pointer(s))
|
|
PostIncUintptr(&s, 1)
|
|
}
|
|
|
|
sp := *(*byte)(unsafe.Pointer(s))
|
|
|
|
if (base == 0 || base == 16) &&
|
|
c == '0' && (sp == 'x' || sp == 'X') {
|
|
PostIncUintptr(&s, 1)
|
|
c = *(*byte)(unsafe.Pointer(s)) //s[1];
|
|
PostIncUintptr(&s, 1)
|
|
base = 16
|
|
}
|
|
if base == 0 {
|
|
if c == '0' {
|
|
base = 0
|
|
} else {
|
|
base = 10
|
|
}
|
|
}
|
|
var ULONG_MAX ulong = 0xFFFFFFFF
|
|
|
|
cutoff = ULONG_MAX / ulong(base)
|
|
cutlim = int32(ULONG_MAX % ulong(base))
|
|
|
|
acc = 0
|
|
any = 0
|
|
|
|
for {
|
|
var cs = string(c)
|
|
if unicode.IsDigit([]rune(cs)[0]) {
|
|
c -= '0'
|
|
} else if unicode.IsLetter([]rune(cs)[0]) {
|
|
if unicode.IsUpper([]rune(cs)[0]) {
|
|
c -= 'A' - 10
|
|
} else {
|
|
c -= 'a' - 10
|
|
}
|
|
} else {
|
|
break
|
|
}
|
|
|
|
if int32(c) >= base {
|
|
break
|
|
}
|
|
if any < 0 || acc > cutoff || (acc == cutoff && int32(c) > cutlim) {
|
|
any = -1
|
|
|
|
} else {
|
|
any = 1
|
|
acc *= ulong(base)
|
|
acc += ulong(c)
|
|
}
|
|
|
|
c = *(*byte)(unsafe.Pointer(s))
|
|
PostIncUintptr(&s, 1)
|
|
}
|
|
|
|
if any < 0 {
|
|
acc = ULONG_MAX
|
|
t.setErrno(errno.ERANGE)
|
|
} else if neg == 1 {
|
|
acc = -acc
|
|
}
|
|
|
|
if endptr != 0 {
|
|
if any == 1 {
|
|
PostDecUintptr(&s, 1)
|
|
AssignPtrUintptr(endptr, s)
|
|
} else {
|
|
AssignPtrUintptr(endptr, nptr)
|
|
}
|
|
}
|
|
return acc
|
|
}
|
|
|
|
// int __isoc99_sscanf(const char *str, const char *format, ...);
|
|
func X__isoc99_sscanf(t *TLS, str, format, va uintptr) int32 {
|
|
r := scanf(strings.NewReader(GoString(str)), format, va)
|
|
// if dmesgs {
|
|
// dmesg("%v: %q %q: %d", origin(1), GoString(str), GoString(format), r)
|
|
// }
|
|
return r
|
|
}
|
|
|
|
// int sscanf(const char *str, const char *format, ...);
|
|
func Xsscanf(t *TLS, str, format, va uintptr) int32 {
|
|
r := scanf(strings.NewReader(GoString(str)), format, va)
|
|
// if dmesgs {
|
|
// dmesg("%v: %q %q: %d", origin(1), GoString(str), GoString(format), r)
|
|
// }
|
|
return r
|
|
}
|
|
|
|
func Xstrtod(tls *TLS, s uintptr, p uintptr) float64 { /* strtod.c:22:8: */
|
|
panic(todo(""))
|
|
}
|
|
|
|
func Xrint(tls *TLS, x float64) float64 {
|
|
switch {
|
|
case x == 0: // also +0 and -0
|
|
return 0
|
|
case math.IsInf(x, 0), math.IsNaN(x):
|
|
return x
|
|
case x >= math.MinInt64 && x <= math.MaxInt64 && float64(int64(x)) == x:
|
|
return x
|
|
case x >= 0:
|
|
return math.Floor(x + 0.5)
|
|
default:
|
|
return math.Ceil(x - 0.5)
|
|
}
|
|
}
|
|
|
|
// FILE *fdopen(int fd, const char *mode);
|
|
func Xfdopen(t *TLS, fd int32, mode uintptr) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// struct tm *_gmtime64( const __time64_t *sourceTime );
|
|
func X_gmtime64(t *TLS, sourceTime uintptr) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// __time64_t _mktime64(struct tm *timeptr);
|
|
func X_mktime64(t *TLS, timeptr uintptr) time.X__time64_t {
|
|
return time.X__time64_t(Xmktime(t, timeptr))
|
|
}
|
|
|
|
// char * gai_strerrorA(int ecode);
|
|
func Xgai_strerrorA(t *TLS, ecode int32) uintptr {
|
|
panic(todo(""))
|
|
}
|
|
|
|
// https://github.com/Alexpux/mingw-w64/blob/master/mingw-w64-headers/crt/sys/timeb.h#L69
|
|
//
|
|
// struct __timeb64 {
|
|
// __time64_t time;
|
|
// unsigned short millitm;
|
|
// short timezone;
|
|
// short dstflag;
|
|
// };
|
|
|
|
type __timeb64 struct {
|
|
time types.X__time64_t
|
|
millitm uint32
|
|
timezone int16
|
|
dstflag int16
|
|
}
|
|
|
|
// void _ftime64( struct __timeb64 *timeptr );
|
|
func X_ftime64(t *TLS, timeptr uintptr) {
|
|
tm := gotime.Now()
|
|
(*__timeb64)(unsafe.Pointer(timeptr)).time = types.X__time64_t(tm.Unix())
|
|
|
|
//TODO When Go 1.16 is no more supported
|
|
// (*__timeb64)(unsafe.Pointer(timeptr)).millitm = uint32(tm.UnixMilli() % 1000)
|
|
|
|
(*__timeb64)(unsafe.Pointer(timeptr)).millitm = uint32(int64(tm.Nanosecond()) / 1e6)
|
|
}
|
|
|
|
func X__ccgo_getMutexType(tls *TLS, m uintptr) int32 { /* pthread_mutex_lock.c:3:5: */
|
|
return *(*int32)(unsafe.Pointer(m)) & 15
|
|
}
|
|
|
|
func X__ccgo_pthreadAttrGetDetachState(tls *TLS, a uintptr) int32 { /* pthread_attr_get.c:3:5: */
|
|
return *(*int32)(unsafe.Pointer(a))
|
|
}
|
|
|
|
func X__ccgo_pthreadMutexattrGettype(tls *TLS, a uintptr) int32 { /* pthread_attr_get.c:93:5: */
|
|
return *(*int32)(unsafe.Pointer(a)) & int32(3)
|
|
}
|
|
|
|
func Xchmod(t *TLS, pathname uintptr, mode int32) int32 {
|
|
panic(todo("%q %#o", GoString(pathname), mode))
|
|
}
|
|
|
|
// typedef enum _COMPUTER_NAME_FORMAT {
|
|
// ComputerNameNetBIOS,
|
|
// ComputerNameDnsHostname,
|
|
// ComputerNameDnsDomain,
|
|
// ComputerNameDnsFullyQualified,
|
|
// ComputerNamePhysicalNetBIOS,
|
|
// ComputerNamePhysicalDnsHostname,
|
|
// ComputerNamePhysicalDnsDomain,
|
|
// ComputerNamePhysicalDnsFullyQualified,
|
|
// ComputerNameMax
|
|
// } COMPUTER_NAME_FORMAT;
|
|
|
|
// BOOL GetComputerNameExW(
|
|
//
|
|
// [in] COMPUTER_NAME_FORMAT NameType,
|
|
// [out] LPWSTR lpBuffer,
|
|
// [in, out] LPDWORD nSize
|
|
//
|
|
// );
|
|
func XGetComputerNameExW(t *TLS, nameType int32, lpBuffer, nSize uintptr) int32 {
|
|
r0, _, err := syscall.Syscall(procGetComputerNameExW.Addr(), 3, uintptr(nameType), lpBuffer, nSize)
|
|
if err != 0 {
|
|
t.setErrno(err)
|
|
}
|
|
return int32(r0)
|
|
}
|
|
|
|
// double _copysign(
|
|
//
|
|
// double x,
|
|
// double y
|
|
//
|
|
// );
|
|
func X_copysign(t *TLS, x, y float64) float64 { return Xcopysign(t, x, y) }
|
|
|
|
// int _wtoi(
|
|
//
|
|
// const wchar_t *str
|
|
//
|
|
// );
|
|
func X_wtoi(t *TLS, str uintptr) int32 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
func allocW(t *TLS, v string) (r uintptr) {
|
|
s := utf16.Encode([]rune(v))
|
|
p := Xcalloc(t, types.Size_t(len(s)+1), 2)
|
|
if p == 0 {
|
|
panic(todo(""))
|
|
}
|
|
|
|
r = p
|
|
for _, v := range s {
|
|
*(*uint16)(unsafe.Pointer(p)) = v
|
|
p += 2
|
|
}
|
|
return r
|
|
}
|
|
|
|
// wchar_t *_wgetenv(
|
|
//
|
|
// const wchar_t *varname
|
|
//
|
|
// );
|
|
func X_wgetenv(t *TLS, varname uintptr) uintptr {
|
|
if !wenvValid {
|
|
bootWinEnviron(t)
|
|
}
|
|
k := strings.ToLower(goWideStringNZ(varname))
|
|
for _, v := range winEnviron[:len(winEnviron)-1] {
|
|
s := strings.ToLower(goWideStringNZ(v))
|
|
x := strings.IndexByte(s, '=')
|
|
if s[:x] == k {
|
|
// trc("%v: %q -> %q", origin(1), goWideStringNZ(varname), goWideStringNZ(v))
|
|
return v
|
|
}
|
|
}
|
|
|
|
// trc("%v: %q -> %q", origin(1), goWideStringNZ(varname), "")
|
|
return 0
|
|
}
|
|
|
|
// int _wputenv(
|
|
//
|
|
// const wchar_t *envstring
|
|
//
|
|
// );
|
|
func X_wputenv(t *TLS, envstring uintptr) int32 {
|
|
if !wenvValid {
|
|
bootWinEnviron(t)
|
|
}
|
|
s0 := goWideStringNZ(envstring)
|
|
s := strings.ToLower(s0)
|
|
x := strings.IndexByte(s, '=')
|
|
k := s[:x]
|
|
for i, v := range winEnviron[:len(winEnviron)-1] {
|
|
s2 := strings.ToLower(goWideStringNZ(v))
|
|
x := strings.IndexByte(s2, '=')
|
|
if s2[:x] == k {
|
|
Xfree(t, v)
|
|
winEnviron[i] = allocW(t, s0)
|
|
return 0
|
|
}
|
|
}
|
|
|
|
np := allocW(t, s0)
|
|
winEnviron = winEnviron[:len(winEnviron)-1]
|
|
winEnviron = append(winEnviron, np, 0)
|
|
wenviron = uintptr(unsafe.Pointer(&winEnviron[0]))
|
|
return 0
|
|
}
|
|
|
|
func bootWinEnviron(t *TLS) {
|
|
winEnviron = winEnviron[:0]
|
|
p := Environ()
|
|
for {
|
|
q := *(*uintptr)(unsafe.Pointer(p))
|
|
p += unsafe.Sizeof(uintptr(0))
|
|
if q == 0 {
|
|
break
|
|
}
|
|
|
|
s := GoString(q)
|
|
// trc("%v: %q", origin(1), s)
|
|
r := allocW(t, s)
|
|
winEnviron = append(winEnviron, r)
|
|
}
|
|
wenviron = uintptr(unsafe.Pointer(&winEnviron[0]))
|
|
wenvValid = true
|
|
}
|
|
|
|
func Xfabsl(t *TLS, x float64) float64 { return math.Abs(x) }
|
|
|
|
func X__stdio_common_vfprintf(t *TLS, args ...interface{}) int32 { panic("TODO") }
|
|
func X__stdio_common_vfprintf_p(t *TLS, args ...interface{}) int32 { panic("TODO") }
|
|
func X__stdio_common_vfprintf_s(t *TLS, args ...interface{}) int32 { panic("TODO") }
|
|
func X__stdio_common_vfscanf(t *TLS, args ...interface{}) int32 { panic("TODO") }
|
|
func X__stdio_common_vfwprintf_s(t *TLS, args ...interface{}) int32 { panic("TODO") }
|
|
func X__stdio_common_vfwscanf(t *TLS, args ...interface{}) int32 { panic("TODO") }
|
|
func X__stdio_common_vsnprintf_s(t *TLS, args ...interface{}) int32 { panic("TODO") }
|
|
func X__stdio_common_vsnwprintf_s(t *TLS, args ...interface{}) int32 { panic("TODO") }
|
|
func X__stdio_common_vsprintf(t *TLS, args ...interface{}) int32 { panic("TODO") }
|
|
func X__stdio_common_vsprintf_p(t *TLS, args ...interface{}) int32 { panic("TODO") }
|
|
func X__stdio_common_vsprintf_s(t *TLS, args ...interface{}) int32 { panic("TODO") }
|
|
func X__stdio_common_vsscanf(t *TLS, args ...interface{}) int32 { panic("TODO") }
|
|
func X__stdio_common_vswprintf(t *TLS, args ...interface{}) int32 { panic("TODO") }
|
|
func X__stdio_common_vswprintf_s(t *TLS, args ...interface{}) int32 { panic("TODO") }
|
|
func X__stdio_common_vswscanf(t *TLS, args ...interface{}) int32 { panic("TODO") }
|