353 lines
6.4 KiB
Go
353 lines
6.4 KiB
Go
// Copyright 2018 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// +build js,wasm
|
|
|
|
package syscall
|
|
|
|
import (
|
|
"internal/oserror"
|
|
"sync"
|
|
"unsafe"
|
|
)
|
|
|
|
const direntSize = 8 + 8 + 2 + 256
|
|
|
|
type Dirent struct {
|
|
Reclen uint16
|
|
Name [256]byte
|
|
}
|
|
|
|
func direntIno(buf []byte) (uint64, bool) {
|
|
return 1, true
|
|
}
|
|
|
|
func direntReclen(buf []byte) (uint64, bool) {
|
|
return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))
|
|
}
|
|
|
|
func direntNamlen(buf []byte) (uint64, bool) {
|
|
reclen, ok := direntReclen(buf)
|
|
if !ok {
|
|
return 0, false
|
|
}
|
|
return reclen - uint64(unsafe.Offsetof(Dirent{}.Name)), true
|
|
}
|
|
|
|
const PathMax = 256
|
|
|
|
// An Errno is an unsigned number describing an error condition.
|
|
// It implements the error interface. The zero Errno is by convention
|
|
// a non-error, so code to convert from Errno to error should use:
|
|
// err = nil
|
|
// if errno != 0 {
|
|
// err = errno
|
|
// }
|
|
type Errno uintptr
|
|
|
|
func (e Errno) Error() string {
|
|
if 0 <= int(e) && int(e) < len(errorstr) {
|
|
s := errorstr[e]
|
|
if s != "" {
|
|
return s
|
|
}
|
|
}
|
|
return "errno " + itoa(int(e))
|
|
}
|
|
|
|
func (e Errno) Is(target error) bool {
|
|
switch target {
|
|
case oserror.ErrPermission:
|
|
return e == EACCES || e == EPERM
|
|
case oserror.ErrExist:
|
|
return e == EEXIST || e == ENOTEMPTY
|
|
case oserror.ErrNotExist:
|
|
return e == ENOENT
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (e Errno) Temporary() bool {
|
|
return e == EINTR || e == EMFILE || e.Timeout()
|
|
}
|
|
|
|
func (e Errno) Timeout() bool {
|
|
return e == EAGAIN || e == EWOULDBLOCK || e == ETIMEDOUT
|
|
}
|
|
|
|
// A Signal is a number describing a process signal.
|
|
// It implements the os.Signal interface.
|
|
type Signal int
|
|
|
|
const (
|
|
_ Signal = iota
|
|
SIGCHLD
|
|
SIGINT
|
|
SIGKILL
|
|
SIGTRAP
|
|
SIGQUIT
|
|
SIGTERM
|
|
)
|
|
|
|
func (s Signal) Signal() {}
|
|
|
|
func (s Signal) String() string {
|
|
if 0 <= s && int(s) < len(signals) {
|
|
str := signals[s]
|
|
if str != "" {
|
|
return str
|
|
}
|
|
}
|
|
return "signal " + itoa(int(s))
|
|
}
|
|
|
|
var signals = [...]string{}
|
|
|
|
// File system
|
|
|
|
const (
|
|
Stdin = 0
|
|
Stdout = 1
|
|
Stderr = 2
|
|
)
|
|
|
|
const (
|
|
O_RDONLY = 0
|
|
O_WRONLY = 1
|
|
O_RDWR = 2
|
|
|
|
O_CREAT = 0100
|
|
O_CREATE = O_CREAT
|
|
O_TRUNC = 01000
|
|
O_APPEND = 02000
|
|
O_EXCL = 0200
|
|
O_SYNC = 010000
|
|
|
|
O_CLOEXEC = 0
|
|
)
|
|
|
|
const (
|
|
F_DUPFD = 0
|
|
F_GETFD = 1
|
|
F_SETFD = 2
|
|
F_GETFL = 3
|
|
F_SETFL = 4
|
|
F_GETOWN = 5
|
|
F_SETOWN = 6
|
|
F_GETLK = 7
|
|
F_SETLK = 8
|
|
F_SETLKW = 9
|
|
F_RGETLK = 10
|
|
F_RSETLK = 11
|
|
F_CNVT = 12
|
|
F_RSETLKW = 13
|
|
|
|
F_RDLCK = 1
|
|
F_WRLCK = 2
|
|
F_UNLCK = 3
|
|
F_UNLKSYS = 4
|
|
)
|
|
|
|
const (
|
|
S_IFMT = 0000370000
|
|
S_IFSHM_SYSV = 0000300000
|
|
S_IFSEMA = 0000270000
|
|
S_IFCOND = 0000260000
|
|
S_IFMUTEX = 0000250000
|
|
S_IFSHM = 0000240000
|
|
S_IFBOUNDSOCK = 0000230000
|
|
S_IFSOCKADDR = 0000220000
|
|
S_IFDSOCK = 0000210000
|
|
|
|
S_IFSOCK = 0000140000
|
|
S_IFLNK = 0000120000
|
|
S_IFREG = 0000100000
|
|
S_IFBLK = 0000060000
|
|
S_IFDIR = 0000040000
|
|
S_IFCHR = 0000020000
|
|
S_IFIFO = 0000010000
|
|
|
|
S_UNSUP = 0000370000
|
|
|
|
S_ISUID = 0004000
|
|
S_ISGID = 0002000
|
|
S_ISVTX = 0001000
|
|
|
|
S_IREAD = 0400
|
|
S_IWRITE = 0200
|
|
S_IEXEC = 0100
|
|
|
|
S_IRWXU = 0700
|
|
S_IRUSR = 0400
|
|
S_IWUSR = 0200
|
|
S_IXUSR = 0100
|
|
|
|
S_IRWXG = 070
|
|
S_IRGRP = 040
|
|
S_IWGRP = 020
|
|
S_IXGRP = 010
|
|
|
|
S_IRWXO = 07
|
|
S_IROTH = 04
|
|
S_IWOTH = 02
|
|
S_IXOTH = 01
|
|
)
|
|
|
|
type Stat_t struct {
|
|
Dev int64
|
|
Ino uint64
|
|
Mode uint32
|
|
Nlink uint32
|
|
Uid uint32
|
|
Gid uint32
|
|
Rdev int64
|
|
Size int64
|
|
Blksize int32
|
|
Blocks int32
|
|
Atime int64
|
|
AtimeNsec int64
|
|
Mtime int64
|
|
MtimeNsec int64
|
|
Ctime int64
|
|
CtimeNsec int64
|
|
}
|
|
|
|
// Processes
|
|
// Not supported - just enough for package os.
|
|
|
|
var ForkLock sync.RWMutex
|
|
|
|
type WaitStatus uint32
|
|
|
|
func (w WaitStatus) Exited() bool { return false }
|
|
func (w WaitStatus) ExitStatus() int { return 0 }
|
|
func (w WaitStatus) Signaled() bool { return false }
|
|
func (w WaitStatus) Signal() Signal { return 0 }
|
|
func (w WaitStatus) CoreDump() bool { return false }
|
|
func (w WaitStatus) Stopped() bool { return false }
|
|
func (w WaitStatus) Continued() bool { return false }
|
|
func (w WaitStatus) StopSignal() Signal { return 0 }
|
|
func (w WaitStatus) TrapCause() int { return 0 }
|
|
|
|
// XXX made up
|
|
type Rusage struct {
|
|
Utime Timeval
|
|
Stime Timeval
|
|
}
|
|
|
|
// XXX made up
|
|
type ProcAttr struct {
|
|
Dir string
|
|
Env []string
|
|
Files []uintptr
|
|
Sys *SysProcAttr
|
|
}
|
|
|
|
type SysProcAttr struct {
|
|
}
|
|
|
|
func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) {
|
|
return 0, 0, ENOSYS
|
|
}
|
|
|
|
func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) {
|
|
return 0, 0, ENOSYS
|
|
}
|
|
|
|
func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) {
|
|
return 0, 0, ENOSYS
|
|
}
|
|
|
|
func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) {
|
|
return 0, 0, ENOSYS
|
|
}
|
|
|
|
func Sysctl(key string) (string, error) {
|
|
if key == "kern.hostname" {
|
|
return "js", nil
|
|
}
|
|
return "", ENOSYS
|
|
}
|
|
|
|
const ImplementsGetwd = true
|
|
|
|
func Getwd() (wd string, err error) {
|
|
var buf [PathMax]byte
|
|
n, err := Getcwd(buf[0:])
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return string(buf[:n]), nil
|
|
}
|
|
|
|
func Getuid() int {
|
|
return jsProcess.Call("getuid").Int()
|
|
}
|
|
|
|
func Getgid() int {
|
|
return jsProcess.Call("getgid").Int()
|
|
}
|
|
|
|
func Geteuid() int {
|
|
return jsProcess.Call("geteuid").Int()
|
|
}
|
|
|
|
func Getegid() int {
|
|
return jsProcess.Call("getegid").Int()
|
|
}
|
|
|
|
func Getgroups() ([]int, error) {
|
|
array := jsProcess.Call("getgroups")
|
|
groups := make([]int, array.Length())
|
|
for i := range groups {
|
|
groups[i] = array.Index(i).Int()
|
|
}
|
|
return groups, nil
|
|
}
|
|
|
|
func Getpid() int {
|
|
return jsProcess.Get("pid").Int()
|
|
}
|
|
|
|
func Getppid() int {
|
|
return jsProcess.Get("ppid").Int()
|
|
}
|
|
|
|
func Umask(mask int) (oldmask int) {
|
|
return jsProcess.Call("umask", mask).Int()
|
|
}
|
|
|
|
func Gettimeofday(tv *Timeval) error { return ENOSYS }
|
|
|
|
func Kill(pid int, signum Signal) error { return ENOSYS }
|
|
func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
|
|
return 0, ENOSYS
|
|
}
|
|
func StartProcess(argv0 string, argv []string, attr *ProcAttr) (pid int, handle uintptr, err error) {
|
|
return 0, 0, ENOSYS
|
|
}
|
|
func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) {
|
|
return 0, ENOSYS
|
|
}
|
|
|
|
type Iovec struct{} // dummy
|
|
|
|
type Timespec struct {
|
|
Sec int64
|
|
Nsec int64
|
|
}
|
|
|
|
type Timeval struct {
|
|
Sec int64
|
|
Usec int64
|
|
}
|
|
|
|
func setTimespec(sec, nsec int64) Timespec {
|
|
return Timespec{Sec: sec, Nsec: nsec}
|
|
}
|
|
|
|
func setTimeval(sec, usec int64) Timeval {
|
|
return Timeval{Sec: sec, Usec: usec}
|
|
}
|