at.mx raw

   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  //go:build dragonfly || freebsd || linux || netbsd || (openbsd && mips64)
   6  
   7  package unix
   8  
   9  import (
  10  	"syscall"
  11  	"unsafe"
  12  )
  13  
  14  func Unlinkat(dirfd int, path string, flags int) error {
  15  	p, err := syscall.BytePtrFromString(path)
  16  	if err != nil {
  17  		return err
  18  	}
  19  
  20  	_, _, errno := syscall.Syscall(unlinkatTrap, uintptr(dirfd), uintptr(unsafe.Pointer(p)), uintptr(flags))
  21  	if errno != 0 {
  22  		return errno
  23  	}
  24  
  25  	return nil
  26  }
  27  
  28  func Openat(dirfd int, path string, flags int, perm uint32) (int, error) {
  29  	p, err := syscall.BytePtrFromString(path)
  30  	if err != nil {
  31  		return 0, err
  32  	}
  33  
  34  	fd, _, errno := syscall.Syscall6(openatTrap, uintptr(dirfd), uintptr(unsafe.Pointer(p)), uintptr(flags), uintptr(perm), 0, 0)
  35  	if errno != 0 {
  36  		return 0, errno
  37  	}
  38  
  39  	return int(fd), nil
  40  }
  41  
  42  func Readlinkat(dirfd int, path string, buf []byte) (int, error) {
  43  	p0, err := syscall.BytePtrFromString(path)
  44  	if err != nil {
  45  		return 0, err
  46  	}
  47  	var p1 unsafe.Pointer
  48  	if len(buf) > 0 {
  49  		p1 = unsafe.Pointer(&buf[0])
  50  	} else {
  51  		p1 = unsafe.Pointer(&_zero)
  52  	}
  53  	n, _, errno := syscall.Syscall6(readlinkatTrap,
  54  		uintptr(dirfd),
  55  		uintptr(unsafe.Pointer(p0)),
  56  		uintptr(p1),
  57  		uintptr(len(buf)),
  58  		0, 0)
  59  	if errno != 0 {
  60  		return 0, errno
  61  	}
  62  
  63  	return int(n), nil
  64  }
  65  
  66  func Mkdirat(dirfd int, path string, mode uint32) error {
  67  	p, err := syscall.BytePtrFromString(path)
  68  	if err != nil {
  69  		return err
  70  	}
  71  
  72  	_, _, errno := syscall.Syscall6(mkdiratTrap,
  73  		uintptr(dirfd),
  74  		uintptr(unsafe.Pointer(p)),
  75  		uintptr(mode),
  76  		0, 0, 0)
  77  	if errno != 0 {
  78  		return errno
  79  	}
  80  	return nil
  81  }
  82  
  83  func Fchmodat(dirfd int, path string, mode uint32, flags int) error {
  84  	p, err := syscall.BytePtrFromString(path)
  85  	if err != nil {
  86  		return err
  87  	}
  88  	_, _, errno := syscall.Syscall6(fchmodatTrap,
  89  		uintptr(dirfd),
  90  		uintptr(unsafe.Pointer(p)),
  91  		uintptr(mode),
  92  		uintptr(flags),
  93  		0, 0)
  94  	if errno != 0 {
  95  		return errno
  96  	}
  97  	return nil
  98  }
  99  
 100  func Fchownat(dirfd int, path string, uid, gid int, flags int) error {
 101  	p, err := syscall.BytePtrFromString(path)
 102  	if err != nil {
 103  		return err
 104  	}
 105  	_, _, errno := syscall.Syscall6(fchownatTrap,
 106  		uintptr(dirfd),
 107  		uintptr(unsafe.Pointer(p)),
 108  		uintptr(uid),
 109  		uintptr(gid),
 110  		uintptr(flags),
 111  		0)
 112  	if errno != 0 {
 113  		return errno
 114  	}
 115  	return nil
 116  }
 117  
 118  func Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) error {
 119  	oldp, err := syscall.BytePtrFromString(oldpath)
 120  	if err != nil {
 121  		return err
 122  	}
 123  	newp, err := syscall.BytePtrFromString(newpath)
 124  	if err != nil {
 125  		return err
 126  	}
 127  	_, _, errno := syscall.Syscall6(renameatTrap,
 128  		uintptr(olddirfd),
 129  		uintptr(unsafe.Pointer(oldp)),
 130  		uintptr(newdirfd),
 131  		uintptr(unsafe.Pointer(newp)),
 132  		0,
 133  		0)
 134  	if errno != 0 {
 135  		return errno
 136  	}
 137  	return nil
 138  }
 139  
 140  func Linkat(olddirfd int, oldpath string, newdirfd int, newpath string, flag int) error {
 141  	oldp, err := syscall.BytePtrFromString(oldpath)
 142  	if err != nil {
 143  		return err
 144  	}
 145  	newp, err := syscall.BytePtrFromString(newpath)
 146  	if err != nil {
 147  		return err
 148  	}
 149  	_, _, errno := syscall.Syscall6(linkatTrap,
 150  		uintptr(olddirfd),
 151  		uintptr(unsafe.Pointer(oldp)),
 152  		uintptr(newdirfd),
 153  		uintptr(unsafe.Pointer(newp)),
 154  		uintptr(flag),
 155  		0)
 156  	if errno != 0 {
 157  		return errno
 158  	}
 159  	return nil
 160  }
 161  
 162  func Symlinkat(oldpath string, newdirfd int, newpath string) error {
 163  	oldp, err := syscall.BytePtrFromString(oldpath)
 164  	if err != nil {
 165  		return err
 166  	}
 167  	newp, err := syscall.BytePtrFromString(newpath)
 168  	if err != nil {
 169  		return err
 170  	}
 171  	_, _, errno := syscall.Syscall(symlinkatTrap,
 172  		uintptr(unsafe.Pointer(oldp)),
 173  		uintptr(newdirfd),
 174  		uintptr(unsafe.Pointer(newp)))
 175  	if errno != 0 {
 176  		return errno
 177  	}
 178  	return nil
 179  }
 180