libgo/go/syscall/syscall_js.go

   1 // Copyright 2018 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // +build js,wasm
   6
   7 package syscall
   8
   9 import (
  10         "internal/oserror"
  11         "sync"
  12         "unsafe"
  13 )
  14
  15 const direntSize = 8 + 8 + 2 + 256
  16
  17 type Dirent struct {
  18         Reclen uint16
  19         Name   [256]byte
  20 }
  21
  22 func direntIno(buf []byte) (uint64, bool) {
  23         return 1, true
  24 }
  25
  26 func direntReclen(buf []byte) (uint64, bool) {
  27         return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))
  28 }
  29
  30 func direntNamlen(buf []byte) (uint64, bool) {
  31         reclen, ok := direntReclen(buf)
  32         if !ok {
  33                 return 0, false
  34         }
  35         return reclen - uint64(unsafe.Offsetof(Dirent{}.Name)), true
  36 }
  37
  38 const PathMax = 256
  39
  40 // An Errno is an unsigned number describing an error condition.
  41 // It implements the error interface. The zero Errno is by convention
  42 // a non-error, so code to convert from Errno to error should use:
  43 //      err = nil
  44 //      if errno != 0 {
  45 //              err = errno
  46 //      }
  47 //
  48 // Errno values can be tested against error values from the os package
  49 // using errors.Is. For example:
  50 //
  51 //      _, _, err := syscall.Syscall(...)
  52 //      if errors.Is(err, os.ErrNotExist) ...
  53 type Errno uintptr
  54
  55 func (e Errno) Error() string {
  56         if 0 <= int(e) && int(e) < len(errorstr) {
  57                 s := errorstr[e]
  58                 if s != "" {
  59                         return s
  60                 }
  61         }
  62         return "errno " + itoa(int(e))
  63 }
  64
  65 func (e Errno) Is(target error) bool {
  66         switch target {
  67         case oserror.ErrPermission:
  68                 return e == EACCES || e == EPERM
  69         case oserror.ErrExist:
  70                 return e == EEXIST || e == ENOTEMPTY
  71         case oserror.ErrNotExist:
  72                 return e == ENOENT
  73         }
  74         return false
  75 }
  76
  77 func (e Errno) Temporary() bool {
  78         return e == EINTR || e == EMFILE || e.Timeout()
  79 }
  80
  81 func (e Errno) Timeout() bool {
  82         return e == EAGAIN || e == EWOULDBLOCK || e == ETIMEDOUT
  83 }
  84
  85 // A Signal is a number describing a process signal.
  86 // It implements the os.Signal interface.
  87 type Signal int
  88
  89 const (
  90         _ Signal = iota
  91         SIGCHLD
  92         SIGINT
  93         SIGKILL
  94         SIGTRAP
  95         SIGQUIT
  96         SIGTERM
  97 )
  98
  99 func (s Signal) Signal() {}
 100
 101 func (s Signal) String() string {
 102         if 0 <= s && int(s) < len(signals) {
 103                 str := signals[s]
 104                 if str != "" {
 105                         return str
 106                 }
 107         }
 108         return "signal " + itoa(int(s))
 109 }
 110
 111 var signals = [...]string{}
 112
 113 // File system
 114
 115 const (
 116         Stdin  = 0
 117         Stdout = 1
 118         Stderr = 2
 119 )
 120
 121 const (
 122         O_RDONLY = 0
 123         O_WRONLY = 1
 124         O_RDWR   = 2
 125
 126         O_CREAT  = 0100
 127         O_CREATE = O_CREAT
 128         O_TRUNC  = 01000
 129         O_APPEND = 02000
 130         O_EXCL   = 0200
 131         O_SYNC   = 010000
 132
 133         O_CLOEXEC = 0
 134 )
 135
 136 const (
 137         F_DUPFD   = 0
 138         F_GETFD   = 1
 139         F_SETFD   = 2
 140         F_GETFL   = 3
 141         F_SETFL   = 4
 142         F_GETOWN  = 5
 143         F_SETOWN  = 6
 144         F_GETLK   = 7
 145         F_SETLK   = 8
 146         F_SETLKW  = 9
 147         F_RGETLK  = 10
 148         F_RSETLK  = 11
 149         F_CNVT    = 12
 150         F_RSETLKW = 13
 151
 152         F_RDLCK   = 1
 153         F_WRLCK   = 2
 154         F_UNLCK   = 3
 155         F_UNLKSYS = 4
 156 )
 157
 158 const (
 159         S_IFMT        = 0000370000
 160         S_IFSHM_SYSV  = 0000300000
 161         S_IFSEMA      = 0000270000
 162         S_IFCOND      = 0000260000
 163         S_IFMUTEX     = 0000250000
 164         S_IFSHM       = 0000240000
 165         S_IFBOUNDSOCK = 0000230000
 166         S_IFSOCKADDR  = 0000220000
 167         S_IFDSOCK     = 0000210000
 168
 169         S_IFSOCK = 0000140000
 170         S_IFLNK  = 0000120000
 171         S_IFREG  = 0000100000
 172         S_IFBLK  = 0000060000
 173         S_IFDIR  = 0000040000
 174         S_IFCHR  = 0000020000
 175         S_IFIFO  = 0000010000
 176
 177         S_UNSUP = 0000370000
 178
 179         S_ISUID = 0004000
 180         S_ISGID = 0002000
 181         S_ISVTX = 0001000
 182
 183         S_IREAD  = 0400
 184         S_IWRITE = 0200
 185         S_IEXEC  = 0100
 186
 187         S_IRWXU = 0700
 188         S_IRUSR = 0400
 189         S_IWUSR = 0200
 190         S_IXUSR = 0100
 191
 192         S_IRWXG = 070
 193         S_IRGRP = 040
 194         S_IWGRP = 020
 195         S_IXGRP = 010
 196
 197         S_IRWXO = 07
 198         S_IROTH = 04
 199         S_IWOTH = 02
 200         S_IXOTH = 01
 201 )
 202
 203 type Stat_t struct {
 204         Dev       int64
 205         Ino       uint64
 206         Mode      uint32
 207         Nlink     uint32
 208         Uid       uint32
 209         Gid       uint32
 210         Rdev      int64
 211         Size      int64
 212         Blksize   int32
 213         Blocks    int32
 214         Atime     int64
 215         AtimeNsec int64
 216         Mtime     int64
 217         MtimeNsec int64
 218         Ctime     int64
 219         CtimeNsec int64
 220 }
 221
 222 // Processes
 223 // Not supported - just enough for package os.
 224
 225 var ForkLock sync.RWMutex
 226
 227 type WaitStatus uint32
 228
 229 func (w WaitStatus) Exited() bool       { return false }
 230 func (w WaitStatus) ExitStatus() int    { return 0 }
 231 func (w WaitStatus) Signaled() bool     { return false }
 232 func (w WaitStatus) Signal() Signal     { return 0 }
 233 func (w WaitStatus) CoreDump() bool     { return false }
 234 func (w WaitStatus) Stopped() bool      { return false }
 235 func (w WaitStatus) Continued() bool    { return false }
 236 func (w WaitStatus) StopSignal() Signal { return 0 }
 237 func (w WaitStatus) TrapCause() int     { return 0 }
 238
 239 // XXX made up
 240 type Rusage struct {
 241         Utime Timeval
 242         Stime Timeval
 243 }
 244
 245 // XXX made up
 246 type ProcAttr struct {
 247         Dir   string
 248         Env   []string
 249         Files []uintptr
 250         Sys   *SysProcAttr
 251 }
 252
 253 type SysProcAttr struct {
 254 }
 255
 256 func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) {
 257         return 0, 0, ENOSYS
 258 }
 259
 260 func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) {
 261         return 0, 0, ENOSYS
 262 }
 263
 264 func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) {
 265         return 0, 0, ENOSYS
 266 }
 267
 268 func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) {
 269         return 0, 0, ENOSYS
 270 }
 271
 272 func Sysctl(key string) (string, error) {
 273         if key == "kern.hostname" {
 274                 return "js", nil
 275         }
 276         return "", ENOSYS
 277 }
 278
 279 const ImplementsGetwd = true
 280
 281 func Getwd() (wd string, err error) {
 282         var buf [PathMax]byte
 283         n, err := Getcwd(buf[0:])
 284         if err != nil {
 285                 return "", err
 286         }
 287         return string(buf[:n]), nil
 288 }
 289
 290 func Getuid() int {
 291         return jsProcess.Call("getuid").Int()
 292 }
 293
 294 func Getgid() int {
 295         return jsProcess.Call("getgid").Int()
 296 }
 297
 298 func Geteuid() int {
 299         return jsProcess.Call("geteuid").Int()
 300 }
 301
 302 func Getegid() int {
 303         return jsProcess.Call("getegid").Int()
 304 }
 305
 306 func Getgroups() (groups []int, err error) {
 307         defer recoverErr(&err)
 308         array := jsProcess.Call("getgroups")
 309         groups = make([]int, array.Length())
 310         for i := range groups {
 311                 groups[i] = array.Index(i).Int()
 312         }
 313         return groups, nil
 314 }
 315
 316 func Getpid() int {
 317         return jsProcess.Get("pid").Int()
 318 }
 319
 320 func Getppid() int {
 321         return jsProcess.Get("ppid").Int()
 322 }
 323
 324 func Umask(mask int) (oldmask int) {
 325         return jsProcess.Call("umask", mask).Int()
 326 }
 327
 328 func Gettimeofday(tv *Timeval) error { return ENOSYS }
 329
 330 func Kill(pid int, signum Signal) error { return ENOSYS }
 331 func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
 332         return 0, ENOSYS
 333 }
 334 func StartProcess(argv0 string, argv []string, attr *ProcAttr) (pid int, handle uintptr, err error) {
 335         return 0, 0, ENOSYS
 336 }
 337 func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) {
 338         return 0, ENOSYS
 339 }
 340
 341 type Iovec struct{} // dummy
 342
 343 type Timespec struct {
 344         Sec  int64
 345         Nsec int64
 346 }
 347
 348 type Timeval struct {
 349         Sec  int64
 350         Usec int64
 351 }
 352
 353 func setTimespec(sec, nsec int64) Timespec {
 354         return Timespec{Sec: sec, Nsec: nsec}
 355 }
 356
 357 func setTimeval(sec, usec int64) Timeval {
 358         return Timeval{Sec: sec, Usec: usec}
 359 }