cwinfo/matterbridge
5
0
Fork 0
mirror of https://github.com/cwinfo/matterbridge.git synced 2024-12-26 19:05:40 +00:00
Code Releases Activity
4da1444ffc
matterbridge/vendor/modernc.org/libc/libc_windows.go
Wim e3cafeaf92 Add dependencies/vendor (whatsapp)
2022-03-20 14:57:48 +01:00

5877 lines
150 KiB
Go
Raw Blame History

// 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 := gotime.Local
if r := getenv(Environ(), "TZ"); r != 0 {
zone, off := parseZone(GoString(r))
loc = gotime.FixedZone(zone, -off)
}
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 := gotime.Local
// if r := getenv(Environ(), "TZ"); r != 0 {
// zone, off := parseZone(GoString(r))
// loc = gotime.FixedZone(zone, -off)
// }
// 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) }
View Git Blame Copy Permalink