func Pack(buf co.Buf, i interface{}) error { switch v := i.(type) { case *syscall.Statfs_t: return buf.Pack(native.StatfsToLinux(v)) default: return argjoy.NoMatch } }
func (k *PosixKernel) Lstat(path string, buf co.Buf) uint64 { var stat syscall.Stat_t if err := syscall.Lstat(path, &stat); err != nil { return Errno(err) } targetStat := NewTargetStat(&stat, k.U.OS(), k.U.Bits()) if err := buf.Pack(targetStat); err != nil { panic(err) } return 0 }
func (k *PosixKernel) Fstat(fd co.Fd, buf co.Buf) uint64 { var stat syscall.Stat_t if err := syscall.Fstat(int(fd), &stat); err != nil { return Errno(err) } targetStat := NewTargetStat(&stat, k.U.OS(), k.U.Bits()) if err := buf.Pack(targetStat); err != nil { panic(err) } return 0 }
func (k *PosixKernel) Getcwd(buf co.Buf, size co.Len) uint64 { wd, _ := os.Getwd() size -= 1 if co.Len(len(wd)) > size { wd = wd[:size] } if err := buf.Pack(wd + "\x00"); err != nil { return UINT64_MAX // FIXME } return 0 }
func (k *MachKernel) MachVmAllocate(unk int, size co.Len, addrOut co.Buf) uint64 { mmap, err := k.U.Mmap(0, uint64(size)) if err != nil { return posix.UINT64_MAX // FIXME } var tmp [8]byte buf, _ := k.U.PackAddr(tmp[:], mmap.Addr) if err := addrOut.Pack(buf); err != nil { return posix.UINT64_MAX // FIXME } return 0 }
func (k *PosixKernel) Recvfrom(fd co.Fd, buf co.Buf, size co.Len, flags int, from co.Buf, fromlen co.Len) uint64 { p := make([]byte, size) if n, _, err := syscall.Recvfrom(int(fd), p, flags); err != nil { // TODO: need kernel.Pack() so we can pack a sockaddr into from if err := buf.Pack(p); err != nil { return UINT64_MAX // FIXME } return uint64(n) } else { return UINT64_MAX // FIXME } }
func (k *PosixKernel) Stat(path string, buf co.Buf) uint64 { // TODO: centralize path hook if strings.Contains(path, "/lib/") { path = k.U.PrefixPath(path, false) } var stat syscall.Stat_t if err := syscall.Stat(path, &stat); err != nil { return Errno(err) } targetStat := NewTargetStat(&stat, k.U.OS(), k.U.Bits()) if err := buf.Pack(targetStat); err != nil { panic(err) } return 0 }
func (k *PosixKernel) Getsockopt(fd co.Fd, level, opt int, valueOut, valueSizeOut co.Buf) uint64 { // TODO: dispatch/support both addr and int types value, err := syscall.GetsockoptInt(int(fd), level, opt) if err != nil { return Errno(err) } value32 := int32(value) size := int32(4) if err := valueOut.Pack(value32); err != nil { return UINT64_MAX // FIXME } if err := valueSizeOut.Pack(size); err != nil { return UINT64_MAX // FIXME } return 0 }
func (k *PosixKernel) Getgroups(count int, buf co.Buf) uint64 { groups, err := syscall.Getgroups() if err != nil { return Errno(err) } length := uint64(len(groups)) if count > 0 { if count < len(groups) { groups = groups[:count] } tmp := make([]uint32, len(groups)) for i, v := range groups { tmp[i] = uint32(v) } if err := buf.Pack(tmp); err != nil { return UINT64_MAX // FIXME } } return length }
func (k *PosixKernel) Readlink(path string, buf co.Buf, size co.Len) uint64 { // TODO: full proc emulation layer // maybe have a syscall pre-hook for this after ghostrace makes it generic // or specifically have path hooks and use that to implement prefix as well var name string var err error if path == "/proc/self/exe" && k.U.OS() == "linux" { name = k.U.Exe() } else { name, err = os.Readlink(path) if err != nil { return UINT64_MAX // FIXME } } if len(name) > int(size)-1 { name = name[:size-1] } if err := buf.Pack([]byte(name + "\x00")); err != nil { return UINT64_MAX // FIXME } return uint64(len(name)) }
func Uname(buf co.Buf, un *models.Uname) { buf.Pack(un) }