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)
}