// Copyright 2009 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.

// Linux system calls.

// This file is compiled as ordinary Go code,

// but it is also input to mksyscall,

// which parses the //sys lines and generates system call stubs.

// Note that sometimes we use a lowercase //sys name and

// wrap it in our own nicer implementation.

package unix

import (

	"encoding/binary"

	"strconv"

	"syscall"

	"time"

	"unsafe"

)

/*

 * Wrapped

 */

func Access(path string, mode uint32) (err error) {

	return Faccessat(AT_FDCWD, path, mode, 0)

}

func Chmod(path string, mode uint32) (err error) {

	return Fchmodat(AT_FDCWD, path, mode, 0)

}

func Chown(path string, uid int, gid int) (err error) {

	return Fchownat(AT_FDCWD, path, uid, gid, 0)

}

func Creat(path string, mode uint32) (fd int, err error) {

	return Open(path, O_CREAT|O_WRONLY|O_TRUNC, mode)

}

func EpollCreate(size int) (fd int, err error) {

	if size <= 0 {

		return -1, EINVAL

	}

	return EpollCreate1(0)

}

//sys	FanotifyInit(flags uint, event_f_flags uint) (fd int, err error)

//sys	fanotifyMark(fd int, flags uint, mask uint64, dirFd int, pathname *byte) (err error)

func FanotifyMark(fd int, flags uint, mask uint64, dirFd int, pathname string) (err error) {

	if pathname == "" {

		return fanotifyMark(fd, flags, mask, dirFd, nil)

	}

	p, err := BytePtrFromString(pathname)

	if err != nil {

		return err

	}

	return fanotifyMark(fd, flags, mask, dirFd, p)

}

//sys	fchmodat(dirfd int, path string, mode uint32) (err error)

func Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) {

	// Linux fchmodat doesn't support the flags parameter. Mimick glibc's behavior

	// and check the flags. Otherwise the mode would be applied to the symlink

	// destination which is not what the user expects.

	if flags&^AT_SYMLINK_NOFOLLOW != 0 {

		return EINVAL

	} else if flags&AT_SYMLINK_NOFOLLOW != 0 {

		return EOPNOTSUPP

	}

	return fchmodat(dirfd, path, mode)

}

func InotifyInit() (fd int, err error) {

	return InotifyInit1(0)

}

//sys	ioctl(fd int, req uint, arg uintptr) (err error) = SYS_IOCTL

//sys	ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) = SYS_IOCTL

// ioctl itself should not be exposed directly, but additional get/set functions

// for specific types are permissible. These are defined in ioctl.go and

// ioctl_linux.go.

//

// The third argument to ioctl is often a pointer but sometimes an integer.

// Callers should use ioctlPtr when the third argument is a pointer and ioctl

// when the third argument is an integer.

//

// TODO: some existing code incorrectly uses ioctl when it should use ioctlPtr.

//sys	Linkat(olddirfd int, oldpath string, newdirfd int, newpath string, flags int) (err error)

func Link(oldpath string, newpath string) (err error) {

	return Linkat(AT_FDCWD, oldpath, AT_FDCWD, newpath, 0)

}

func Mkdir(path string, mode uint32) (err error) {

	return Mkdirat(AT_FDCWD, path, mode)

}

func Mknod(path string, mode uint32, dev int) (err error) {

	return Mknodat(AT_FDCWD, path, mode, dev)

}

func Open(path string, mode int, perm uint32) (fd int, err error) {

	return openat(AT_FDCWD, path, mode|O_LARGEFILE, perm)

}

//sys	openat(dirfd int, path string, flags int, mode uint32) (fd int, err error)

func Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) {

	return openat(dirfd, path, flags|O_LARGEFILE, mode)

}

//sys	openat2(dirfd int, path string, open_how *OpenHow, size int) (fd int, err error)

func Openat2(dirfd int, path string, how *OpenHow) (fd int, err error) {

	return openat2(dirfd, path, how, SizeofOpenHow)

}

func Pipe(p []int) error {

	return Pipe2(p, 0)

}

//sysnb	pipe2(p *[2]_C_int, flags int) (err error)

func Pipe2(p []int, flags int) error {

	if len(p) != 2 {

		return EINVAL

	}

	var pp [2]_C_int

	err := pipe2(&pp, flags)

	if err == nil {

		p[0] = int(pp[0])

		p[1] = int(pp[1])

	}

	return err

}

//sys	ppoll(fds *PollFd, nfds int, timeout *Timespec, sigmask *Sigset_t) (n int, err error)

func Ppoll(fds []PollFd, timeout *Timespec, sigmask *Sigset_t) (n int, err error) {

	if len(fds) == 0 {

		return ppoll(nil, 0, timeout, sigmask)

	}

	return ppoll(&fds[0], len(fds), timeout, sigmask)

}

func Poll(fds []PollFd, timeout int) (n int, err error) {

	var ts *Timespec

	if timeout >= 0 {

		ts = new(Timespec)

		*ts = NsecToTimespec(int64(timeout) * 1e6)

	}

	return Ppoll(fds, ts, nil)

}

//sys	Readlinkat(dirfd int, path string, buf []byte) (n int, err error)

func Readlink(path string, buf []byte) (n int, err error) {

	return Readlinkat(AT_FDCWD, path, buf)

}

func Rename(oldpath string, newpath string) (err error) {

	return Renameat(AT_FDCWD, oldpath, AT_FDCWD, newpath)

}

func Rmdir(path string) error {

	return Unlinkat(AT_FDCWD, path, AT_REMOVEDIR)

}

//sys	Symlinkat(oldpath string, newdirfd int, newpath string) (err error)

func Symlink(oldpath string, newpath string) (err error) {

	return Symlinkat(oldpath, AT_FDCWD, newpath)

}

func Unlink(path string) error {

	return Unlinkat(AT_FDCWD, path, 0)

}

//sys	Unlinkat(dirfd int, path string, flags int) (err error)

func Utimes(path string, tv []Timeval) error {

	if tv == nil {

		err := utimensat(AT_FDCWD, path, nil, 0)

		if err != ENOSYS {

			return err

		}

		return utimes(path, nil)

	}

	if len(tv) != 2 {

		return EINVAL

	}

	var ts [2]Timespec

	ts[0] = NsecToTimespec(TimevalToNsec(tv[0]))

	ts[1] = NsecToTimespec(TimevalToNsec(tv[1]))

	err := utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0)

	if err != ENOSYS {

		return err

	}

	return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))

}

//sys	utimensat(dirfd int, path string, times *[2]Timespec, flags int) (err error)

func UtimesNano(path string, ts []Timespec) error {

	return UtimesNanoAt(AT_FDCWD, path, ts, 0)

}

func UtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) error {

	if ts == nil {

		return utimensat(dirfd, path, nil, flags)

	}

	if len(ts) != 2 {

		return EINVAL

	}

	return utimensat(dirfd, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), flags)

}

func Futimesat(dirfd int, path string, tv []Timeval) error {

	if tv == nil {

		return futimesat(dirfd, path, nil)

	}

	if len(tv) != 2 {

		return EINVAL

	}

	return futimesat(dirfd, path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))

}

func Futimes(fd int, tv []Timeval) (err error) {

	// Believe it or not, this is the best we can do on Linux

	// (and is what glibc does).

	return Utimes("/proc/self/fd/"+strconv.Itoa(fd), tv)

}

const ImplementsGetwd = true

//sys	Getcwd(buf []byte) (n int, err error)

func Getwd() (wd string, err error) {

	var buf [PathMax]byte

	n, err := Getcwd(buf[0:])

	if err != nil {

		return "", err

	}

	// Getcwd returns the number of bytes written to buf, including the NUL.

	if n < 1 || n > len(buf) || buf[n-1] != 0 {

		return "", EINVAL

	}

	// In some cases, Linux can return a path that starts with the

	// "(unreachable)" prefix, which can potentially be a valid relative

	// path. To work around that, return ENOENT if path is not absolute.

	if buf[0] != '/' {

		return "", ENOENT

	}

	return string(buf[0 : n-1]), nil

}

func Getgroups() (gids []int, err error) {

	n, err := getgroups(0, nil)

	if err != nil {

		return nil, err

	}

	if n == 0 {

		return nil, nil

	}

	// Sanity check group count. Max is 1<<16 on Linux.

	if n < 0 || n > 1<<20 {

		return nil, EINVAL

	}

	a := make([]_Gid_t, n)

	n, err = getgroups(n, &a[0])

	if err != nil {

		return nil, err

	}

	gids = make([]int, n)

	for i, v := range a[0:n] {

		gids[i] = int(v)

	}

	return

}

func Setgroups(gids []int) (err error) {

	if len(gids) == 0 {

		return setgroups(0, nil)

	}

	a := make([]_Gid_t, len(gids))

	for i, v := range gids {

		a[i] = _Gid_t(v)

	}

	return setgroups(len(a), &a[0])

}

type WaitStatus uint32

// Wait status is 7 bits at bottom, either 0 (exited),

// 0x7F (stopped), or a signal number that caused an exit.

// The 0x80 bit is whether there was a core dump.

// An extra number (exit code, signal causing a stop)

// is in the high bits. At least that's the idea.

// There are various irregularities. For example, the

// "continued" status is 0xFFFF, distinguishing itself

// from stopped via the core dump bit.

const (

	mask    = 0x7F

	core    = 0x80

	exited  = 0x00

	stopped = 0x7F

	shift   = 8

)

func (w WaitStatus) Exited() bool { return w&mask == exited }

func (w WaitStatus) Signaled() bool { return w&mask != stopped && w&mask != exited }

func (w WaitStatus) Stopped() bool { return w&0xFF == stopped }

func (w WaitStatus) Continued() bool { return w == 0xFFFF }

func (w WaitStatus) CoreDump() bool { return w.Signaled() && w&core != 0 }

func (w WaitStatus) ExitStatus() int {

	if !w.Exited() {

		return -1

	}

	return int(w>>shift) & 0xFF

}

func (w WaitStatus) Signal() syscall.Signal {

	if !w.Signaled() {

		return -1

	}

	return syscall.Signal(w & mask)

}

func (w WaitStatus) StopSignal() syscall.Signal {

	if !w.Stopped() {

		return -1

	}

	return syscall.Signal(w>>shift) & 0xFF

}

func (w WaitStatus) TrapCause() int {

	if w.StopSignal() != SIGTRAP {

		return -1

	}

	return int(w>>shift) >> 8

}

//sys	wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error)

func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) {

	var status _C_int

	wpid, err = wait4(pid, &status, options, rusage)

	if wstatus != nil {

		*wstatus = WaitStatus(status)

	}

	return

}

//sys	Waitid(idType int, id int, info *Siginfo, options int, rusage *Rusage) (err error)

func Mkfifo(path string, mode uint32) error {

	return Mknod(path, mode|S_IFIFO, 0)

}

func Mkfifoat(dirfd int, path string, mode uint32) error {

	return Mknodat(dirfd, path, mode|S_IFIFO, 0)

}

func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {

	if sa.Port < 0 || sa.Port > 0xFFFF {

		return nil, 0, EINVAL

	}

	sa.raw.Family = AF_INET

	p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))

	p[0] = byte(sa.Port >> 8)

	p[1] = byte(sa.Port)

	sa.raw.Addr = sa.Addr

	return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil

}

func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) {