130 строки
2,9 КиБ
Go
130 строки
2,9 КиБ
Go
// +build darwin nintendoswitch wasi
|
|
|
|
package syscall
|
|
|
|
import (
|
|
"unsafe"
|
|
)
|
|
|
|
type sliceHeader struct {
|
|
buf *byte
|
|
len uintptr
|
|
cap uintptr
|
|
}
|
|
|
|
func Close(fd int) (err error) {
|
|
if libc_close(int32(fd)) < 0 {
|
|
err = getErrno()
|
|
}
|
|
return
|
|
}
|
|
|
|
func Write(fd int, p []byte) (n int, err error) {
|
|
buf, count := splitSlice(p)
|
|
n = libc_write(int32(fd), buf, uint(count))
|
|
if n < 0 {
|
|
err = getErrno()
|
|
}
|
|
return
|
|
}
|
|
|
|
func Read(fd int, p []byte) (n int, err error) {
|
|
buf, count := splitSlice(p)
|
|
n = libc_read(int32(fd), buf, uint(count))
|
|
if n < 0 {
|
|
err = getErrno()
|
|
}
|
|
return
|
|
}
|
|
|
|
func Seek(fd int, offset int64, whence int) (off int64, err error) {
|
|
return 0, ENOSYS // TODO
|
|
}
|
|
|
|
func Open(path string, flag int, mode uint32) (fd int, err error) {
|
|
data := append([]byte(path), 0)
|
|
fd = int(libc_open(&data[0], int32(flag), mode))
|
|
if fd < 0 {
|
|
err = getErrno()
|
|
}
|
|
return
|
|
}
|
|
|
|
func Mkdir(path string, mode uint32) (err error) {
|
|
return ENOSYS // TODO
|
|
}
|
|
|
|
func Unlink(path string) (err error) {
|
|
return ENOSYS // TODO
|
|
}
|
|
|
|
func Kill(pid int, sig Signal) (err error) {
|
|
return ENOSYS // TODO
|
|
}
|
|
|
|
func Getenv(key string) (value string, found bool) {
|
|
data := append([]byte(key), 0)
|
|
raw := libc_getenv(&data[0])
|
|
if raw == nil {
|
|
return "", false
|
|
}
|
|
|
|
ptr := uintptr(unsafe.Pointer(raw))
|
|
for size := uintptr(0); ; size++ {
|
|
v := *(*byte)(unsafe.Pointer(ptr))
|
|
if v == 0 {
|
|
src := *(*[]byte)(unsafe.Pointer(&sliceHeader{buf: raw, len: size, cap: size}))
|
|
return string(src), true
|
|
}
|
|
ptr += unsafe.Sizeof(byte(0))
|
|
}
|
|
}
|
|
|
|
func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) {
|
|
addr := libc_mmap(nil, uintptr(length), int32(prot), int32(flags), int32(fd), uintptr(offset))
|
|
if addr == unsafe.Pointer(^uintptr(0)) {
|
|
return nil, getErrno()
|
|
}
|
|
return (*[30]byte)(addr)[:length], nil
|
|
}
|
|
|
|
func Mprotect(b []byte, prot int) (err error) {
|
|
errCode := libc_mprotect(unsafe.Pointer(&b[0]), uintptr(len(b)), int32(prot))
|
|
if errCode != 0 {
|
|
err = getErrno()
|
|
}
|
|
return
|
|
}
|
|
|
|
func splitSlice(p []byte) (buf *byte, len uintptr) {
|
|
slice := (*sliceHeader)(unsafe.Pointer(&p))
|
|
return slice.buf, slice.len
|
|
}
|
|
|
|
// ssize_t write(int fd, const void *buf, size_t count)
|
|
//export write
|
|
func libc_write(fd int32, buf *byte, count uint) int
|
|
|
|
// char *getenv(const char *name);
|
|
//export getenv
|
|
func libc_getenv(name *byte) *byte
|
|
|
|
// ssize_t read(int fd, void *buf, size_t count);
|
|
//export read
|
|
func libc_read(fd int32, buf *byte, count uint) int
|
|
|
|
// int open(const char *pathname, int flags, mode_t mode);
|
|
//export open
|
|
func libc_open(pathname *byte, flags int32, mode uint32) int32
|
|
|
|
// int close(int fd)
|
|
//export close
|
|
func libc_close(fd int32) int32
|
|
|
|
// void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
|
|
//export mmap
|
|
func libc_mmap(addr unsafe.Pointer, length uintptr, prot, flags, fd int32, offset uintptr) unsafe.Pointer
|
|
|
|
// int mprotect(void *addr, size_t len, int prot);
|
|
//export mprotect
|
|
func libc_mprotect(addr unsafe.Pointer, len uintptr, prot int32) int32
|