mirror-to-gitea/vendor/golang.org/x/sys/unix/syscall_linux.go
vendor/golang.org/x/sys/unix/syscall_linux.goRaw
1// Copyright 2009 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// Linux system calls.
6// This file is compiled as ordinary Go code,
7// but it is also input to mksyscall,
8// which parses the //sys lines and generates system call stubs.
9// Note that sometimes we use a lowercase //sys name and
10// wrap it in our own nicer implementation.
11
12package unix
13
14import (
15 "encoding/binary"
16 "runtime"
17 "syscall"
18 "unsafe"
19)
20
21/*
22 * Wrapped
23 */
24
25func Access(path string, mode uint32) (err error) {
26 return Faccessat(AT_FDCWD, path, mode, 0)
27}
28
29func Chmod(path string, mode uint32) (err error) {
30 return Fchmodat(AT_FDCWD, path, mode, 0)
31}
32
33func Chown(path string, uid int, gid int) (err error) {
34 return Fchownat(AT_FDCWD, path, uid, gid, 0)
35}
36
37func Creat(path string, mode uint32) (fd int, err error) {
38 return Open(path, O_CREAT|O_WRONLY|O_TRUNC, mode)
39}
40
41//sys FanotifyInit(flags uint, event_f_flags uint) (fd int, err error)
42//sys fanotifyMark(fd int, flags uint, mask uint64, dirFd int, pathname *byte) (err error)
43
44func FanotifyMark(fd int, flags uint, mask uint64, dirFd int, pathname string) (err error) {
45 if pathname == "" {
46 return fanotifyMark(fd, flags, mask, dirFd, nil)
47 }
48 p, err := BytePtrFromString(pathname)
49 if err != nil {
50 return err
51 }
52 return fanotifyMark(fd, flags, mask, dirFd, p)
53}
54
55//sys fchmodat(dirfd int, path string, mode uint32) (err error)
56
57func Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) {
58 // Linux fchmodat doesn't support the flags parameter. Mimick glibc's behavior
59 // and check the flags. Otherwise the mode would be applied to the symlink
60 // destination which is not what the user expects.
61 if flags&^AT_SYMLINK_NOFOLLOW != 0 {
62 return EINVAL
63 } else if flags&AT_SYMLINK_NOFOLLOW != 0 {
64 return EOPNOTSUPP
65 }
66 return fchmodat(dirfd, path, mode)
67}
68
69//sys ioctl(fd int, req uint, arg uintptr) (err error)
70
71// ioctl itself should not be exposed directly, but additional get/set
72// functions for specific types are permissible.
73// These are defined in ioctl.go and ioctl_linux.go.
74
75//sys Linkat(olddirfd int, oldpath string, newdirfd int, newpath string, flags int) (err error)
76
77func Link(oldpath string, newpath string) (err error) {
78 return Linkat(AT_FDCWD, oldpath, AT_FDCWD, newpath, 0)
79}
80
81func Mkdir(path string, mode uint32) (err error) {
82 return Mkdirat(AT_FDCWD, path, mode)
83}
84
85func Mknod(path string, mode uint32, dev int) (err error) {
86 return Mknodat(AT_FDCWD, path, mode, dev)
87}
88
89func Open(path string, mode int, perm uint32) (fd int, err error) {
90 return openat(AT_FDCWD, path, mode|O_LARGEFILE, perm)
91}
92
93//sys openat(dirfd int, path string, flags int, mode uint32) (fd int, err error)
94
95func Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) {
96 return openat(dirfd, path, flags|O_LARGEFILE, mode)
97}
98
99//sys openat2(dirfd int, path string, open_how *OpenHow, size int) (fd int, err error)
100
101func Openat2(dirfd int, path string, how *OpenHow) (fd int, err error) {
102 return openat2(dirfd, path, how, SizeofOpenHow)
103}
104
105//sys ppoll(fds *PollFd, nfds int, timeout *Timespec, sigmask *Sigset_t) (n int, err error)
106
107func Ppoll(fds []PollFd, timeout *Timespec, sigmask *Sigset_t) (n int, err error) {
108 if len(fds) == 0 {
109 return ppoll(nil, 0, timeout, sigmask)
110 }
111 return ppoll(&fds[0], len(fds), timeout, sigmask)
112}
113
114//sys Readlinkat(dirfd int, path string, buf []byte) (n int, err error)
115
116func Readlink(path string, buf []byte) (n int, err error) {
117 return Readlinkat(AT_FDCWD, path, buf)
118}
119
120func Rename(oldpath string, newpath string) (err error) {
121 return Renameat(AT_FDCWD, oldpath, AT_FDCWD, newpath)
122}
123
124func Rmdir(path string) error {
125 return Unlinkat(AT_FDCWD, path, AT_REMOVEDIR)
126}
127
128//sys Symlinkat(oldpath string, newdirfd int, newpath string) (err error)
129
130func Symlink(oldpath string, newpath string) (err error) {
131 return Symlinkat(oldpath, AT_FDCWD, newpath)
132}
133
134func Unlink(path string) error {
135 return Unlinkat(AT_FDCWD, path, 0)
136}
137
138//sys Unlinkat(dirfd int, path string, flags int) (err error)
139
140func Utimes(path string, tv []Timeval) error {
141 if tv == nil {
142 err := utimensat(AT_FDCWD, path, nil, 0)
143 if err != ENOSYS {
144 return err
145 }
146 return utimes(path, nil)
147 }
148 if len(tv) != 2 {
149 return EINVAL
150 }
151 var ts [2]Timespec
152 ts[0] = NsecToTimespec(TimevalToNsec(tv[0]))
153 ts[1] = NsecToTimespec(TimevalToNsec(tv[1]))
154 err := utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0)
155 if err != ENOSYS {
156 return err
157 }
158 return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
159}
160
161//sys utimensat(dirfd int, path string, times *[2]Timespec, flags int) (err error)
162
163func UtimesNano(path string, ts []Timespec) error {
164 if ts == nil {
165 err := utimensat(AT_FDCWD, path, nil, 0)
166 if err != ENOSYS {
167 return err
168 }
169 return utimes(path, nil)
170 }
171 if len(ts) != 2 {
172 return EINVAL
173 }
174 err := utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0)
175 if err != ENOSYS {
176 return err
177 }
178 // If the utimensat syscall isn't available (utimensat was added to Linux
179 // in 2.6.22, Released, 8 July 2007) then fall back to utimes
180 var tv [2]Timeval
181 for i := 0; i < 2; i++ {
182 tv[i] = NsecToTimeval(TimespecToNsec(ts[i]))
183 }
184 return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
185}
186
187func UtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) error {
188 if ts == nil {
189 return utimensat(dirfd, path, nil, flags)
190 }
191 if len(ts) != 2 {
192 return EINVAL
193 }
194 return utimensat(dirfd, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), flags)
195}
196
197func Futimesat(dirfd int, path string, tv []Timeval) error {
198 if tv == nil {
199 return futimesat(dirfd, path, nil)
200 }
201 if len(tv) != 2 {
202 return EINVAL
203 }
204 return futimesat(dirfd, path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
205}
206
207func Futimes(fd int, tv []Timeval) (err error) {
208 // Believe it or not, this is the best we can do on Linux
209 // (and is what glibc does).
210 return Utimes("/proc/self/fd/"+itoa(fd), tv)
211}
212
213const ImplementsGetwd = true
214
215//sys Getcwd(buf []byte) (n int, err error)
216
217func Getwd() (wd string, err error) {
218 var buf [PathMax]byte
219 n, err := Getcwd(buf[0:])
220 if err != nil {
221 return "", err
222 }
223 // Getcwd returns the number of bytes written to buf, including the NUL.
224 if n < 1 || n > len(buf) || buf[n-1] != 0 {
225 return "", EINVAL
226 }
227 return string(buf[0 : n-1]), nil
228}
229
230func Getgroups() (gids []int, err error) {
231 n, err := getgroups(0, nil)
232 if err != nil {
233 return nil, err
234 }
235 if n == 0 {
236 return nil, nil
237 }
238
239 // Sanity check group count. Max is 1<<16 on Linux.
240 if n < 0 || n > 1<<20 {
241 return nil, EINVAL
242 }
243
244 a := make([]_Gid_t, n)
245 n, err = getgroups(n, &a[0])
246 if err != nil {
247 return nil, err
248 }
249 gids = make([]int, n)
250 for i, v := range a[0:n] {
251 gids[i] = int(v)
252 }
253 return
254}
255
256func Setgroups(gids []int) (err error) {
257 if len(gids) == 0 {
258 return setgroups(0, nil)
259 }
260
261 a := make([]_Gid_t, len(gids))
262 for i, v := range gids {
263 a[i] = _Gid_t(v)
264 }
265 return setgroups(len(a), &a[0])
266}
267
268type WaitStatus uint32
269
270// Wait status is 7 bits at bottom, either 0 (exited),
271// 0x7F (stopped), or a signal number that caused an exit.
272// The 0x80 bit is whether there was a core dump.
273// An extra number (exit code, signal causing a stop)
274// is in the high bits. At least that's the idea.
275// There are various irregularities. For example, the
276// "continued" status is 0xFFFF, distinguishing itself
277// from stopped via the core dump bit.
278
279const (
280 mask = 0x7F
281 core = 0x80
282 exited = 0x00
283 stopped = 0x7F
284 shift = 8
285)
286
287func (w WaitStatus) Exited() bool { return w&mask == exited }
288
289func (w WaitStatus) Signaled() bool { return w&mask != stopped && w&mask != exited }
290
291func (w WaitStatus) Stopped() bool { return w&0xFF == stopped }
292
293func (w WaitStatus) Continued() bool { return w == 0xFFFF }
294
295func (w WaitStatus) CoreDump() bool { return w.Signaled() && w&core != 0 }
296
297func (w WaitStatus) ExitStatus() int {
298 if !w.Exited() {
299 return -1
300 }
301 return int(w>>shift) & 0xFF
302}
303
304func (w WaitStatus) Signal() syscall.Signal {
305 if !w.Signaled() {
306 return -1
307 }
308 return syscall.Signal(w & mask)
309}
310
311func (w WaitStatus) StopSignal() syscall.Signal {
312 if !w.Stopped() {
313 return -1
314 }
315 return syscall.Signal(w>>shift) & 0xFF
316}
317
318func (w WaitStatus) TrapCause() int {
319 if w.StopSignal() != SIGTRAP {
320 return -1
321 }
322 return int(w>>shift) >> 8
323}
324
325//sys wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error)
326
327func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) {
328 var status _C_int
329 wpid, err = wait4(pid, &status, options, rusage)
330 if wstatus != nil {
331 *wstatus = WaitStatus(status)
332 }
333 return
334}
335
336func Mkfifo(path string, mode uint32) error {
337 return Mknod(path, mode|S_IFIFO, 0)
338}
339
340func Mkfifoat(dirfd int, path string, mode uint32) error {
341 return Mknodat(dirfd, path, mode|S_IFIFO, 0)
342}
343
344func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {
345 if sa.Port < 0 || sa.Port > 0xFFFF {
346 return nil, 0, EINVAL
347 }
348 sa.raw.Family = AF_INET
349 p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
350 p[0] = byte(sa.Port >> 8)
351 p[1] = byte(sa.Port)
352 for i := 0; i < len(sa.Addr); i++ {
353 sa.raw.Addr[i] = sa.Addr[i]
354 }
355 return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil
356}
357
358func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) {
359 if sa.Port < 0 || sa.Port > 0xFFFF {
360 return nil, 0, EINVAL
361 }
362 sa.raw.Family = AF_INET6
363 p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
364 p[0] = byte(sa.Port >> 8)
365 p[1] = byte(sa.Port)
366 sa.raw.Scope_id = sa.ZoneId
367 for i := 0; i < len(sa.Addr); i++ {
368 sa.raw.Addr[i] = sa.Addr[i]
369 }
370 return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil
371}
372
373func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) {
374 name := sa.Name
375 n := len(name)
376 if n >= len(sa.raw.Path) {
377 return nil, 0, EINVAL
378 }
379 sa.raw.Family = AF_UNIX
380 for i := 0; i < n; i++ {
381 sa.raw.Path[i] = int8(name[i])
382 }
383 // length is family (uint16), name, NUL.
384 sl := _Socklen(2)
385 if n > 0 {
386 sl += _Socklen(n) + 1
387 }
388 if sa.raw.Path[0] == '@' {
389 sa.raw.Path[0] = 0
390 // Don't count trailing NUL for abstract address.
391 sl--
392 }
393
394 return unsafe.Pointer(&sa.raw), sl, nil
395}
396
397// SockaddrLinklayer implements the Sockaddr interface for AF_PACKET type sockets.
398type SockaddrLinklayer struct {
399 Protocol uint16
400 Ifindex int
401 Hatype uint16
402 Pkttype uint8
403 Halen uint8
404 Addr [8]byte
405 raw RawSockaddrLinklayer
406}
407
408func (sa *SockaddrLinklayer) sockaddr() (unsafe.Pointer, _Socklen, error) {
409 if sa.Ifindex < 0 || sa.Ifindex > 0x7fffffff {
410 return nil, 0, EINVAL
411 }
412 sa.raw.Family = AF_PACKET
413 sa.raw.Protocol = sa.Protocol
414 sa.raw.Ifindex = int32(sa.Ifindex)
415 sa.raw.Hatype = sa.Hatype
416 sa.raw.Pkttype = sa.Pkttype
417 sa.raw.Halen = sa.Halen
418 for i := 0; i < len(sa.Addr); i++ {
419 sa.raw.Addr[i] = sa.Addr[i]
420 }
421 return unsafe.Pointer(&sa.raw), SizeofSockaddrLinklayer, nil
422}
423
424// SockaddrNetlink implements the Sockaddr interface for AF_NETLINK type sockets.
425type SockaddrNetlink struct {
426 Family uint16
427 Pad uint16
428 Pid uint32
429 Groups uint32
430 raw RawSockaddrNetlink
431}
432
433func (sa *SockaddrNetlink) sockaddr() (unsafe.Pointer, _Socklen, error) {
434 sa.raw.Family = AF_NETLINK
435 sa.raw.Pad = sa.Pad
436 sa.raw.Pid = sa.Pid
437 sa.raw.Groups = sa.Groups
438 return unsafe.Pointer(&sa.raw), SizeofSockaddrNetlink, nil
439}
440
441// SockaddrHCI implements the Sockaddr interface for AF_BLUETOOTH type sockets
442// using the HCI protocol.
443type SockaddrHCI struct {
444 Dev uint16
445 Channel uint16
446 raw RawSockaddrHCI
447}
448
449func (sa *SockaddrHCI) sockaddr() (unsafe.Pointer, _Socklen, error) {
450 sa.raw.Family = AF_BLUETOOTH
451 sa.raw.Dev = sa.Dev
452 sa.raw.Channel = sa.Channel
453 return unsafe.Pointer(&sa.raw), SizeofSockaddrHCI, nil
454}
455
456// SockaddrL2 implements the Sockaddr interface for AF_BLUETOOTH type sockets
457// using the L2CAP protocol.
458type SockaddrL2 struct {
459 PSM uint16
460 CID uint16
461 Addr [6]uint8
462 AddrType uint8
463 raw RawSockaddrL2
464}
465
466func (sa *SockaddrL2) sockaddr() (unsafe.Pointer, _Socklen, error) {
467 sa.raw.Family = AF_BLUETOOTH
468 psm := (*[2]byte)(unsafe.Pointer(&sa.raw.Psm))
469 psm[0] = byte(sa.PSM)
470 psm[1] = byte(sa.PSM >> 8)
471 for i := 0; i < len(sa.Addr); i++ {
472 sa.raw.Bdaddr[i] = sa.Addr[len(sa.Addr)-1-i]
473 }
474 cid := (*[2]byte)(unsafe.Pointer(&sa.raw.Cid))
475 cid[0] = byte(sa.CID)
476 cid[1] = byte(sa.CID >> 8)
477 sa.raw.Bdaddr_type = sa.AddrType
478 return unsafe.Pointer(&sa.raw), SizeofSockaddrL2, nil
479}
480
481// SockaddrRFCOMM implements the Sockaddr interface for AF_BLUETOOTH type sockets
482// using the RFCOMM protocol.
483//
484// Server example:
485//
486// fd, _ := Socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM)
487// _ = unix.Bind(fd, &unix.SockaddrRFCOMM{
488// Channel: 1,
489// Addr: [6]uint8{0, 0, 0, 0, 0, 0}, // BDADDR_ANY or 00:00:00:00:00:00
490// })
491// _ = Listen(fd, 1)
492// nfd, sa, _ := Accept(fd)
493// fmt.Printf("conn addr=%v fd=%d", sa.(*unix.SockaddrRFCOMM).Addr, nfd)
494// Read(nfd, buf)
495//
496// Client example:
497//
498// fd, _ := Socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM)
499// _ = Connect(fd, &SockaddrRFCOMM{
500// Channel: 1,
501// Addr: [6]byte{0x11, 0x22, 0x33, 0xaa, 0xbb, 0xcc}, // CC:BB:AA:33:22:11
502// })
503// Write(fd, []byte(`hello`))
504type SockaddrRFCOMM struct {
505 // Addr represents a bluetooth address, byte ordering is little-endian.
506 Addr [6]uint8
507
508 // Channel is a designated bluetooth channel, only 1-30 are available for use.
509 // Since Linux 2.6.7 and further zero value is the first available channel.
510 Channel uint8
511
512 raw RawSockaddrRFCOMM
513}
514
515func (sa *SockaddrRFCOMM) sockaddr() (unsafe.Pointer, _Socklen, error) {
516 sa.raw.Family = AF_BLUETOOTH
517 sa.raw.Channel = sa.Channel
518 sa.raw.Bdaddr = sa.Addr
519 return unsafe.Pointer(&sa.raw), SizeofSockaddrRFCOMM, nil
520}
521
522// SockaddrCAN implements the Sockaddr interface for AF_CAN type sockets.
523// The RxID and TxID fields are used for transport protocol addressing in
524// (CAN_TP16, CAN_TP20, CAN_MCNET, and CAN_ISOTP), they can be left with
525// zero values for CAN_RAW and CAN_BCM sockets as they have no meaning.
526//
527// The SockaddrCAN struct must be bound to the socket file descriptor
528// using Bind before the CAN socket can be used.
529//
530// // Read one raw CAN frame
531// fd, _ := Socket(AF_CAN, SOCK_RAW, CAN_RAW)
532// addr := &SockaddrCAN{Ifindex: index}
533// Bind(fd, addr)
534// frame := make([]byte, 16)
535// Read(fd, frame)
536//
537// The full SocketCAN documentation can be found in the linux kernel
538// archives at: https://www.kernel.org/doc/Documentation/networking/can.txt
539type SockaddrCAN struct {
540 Ifindex int
541 RxID uint32
542 TxID uint32
543 raw RawSockaddrCAN
544}
545
546func (sa *SockaddrCAN) sockaddr() (unsafe.Pointer, _Socklen, error) {
547 if sa.Ifindex < 0 || sa.Ifindex > 0x7fffffff {
548 return nil, 0, EINVAL
549 }
550 sa.raw.Family = AF_CAN
551 sa.raw.Ifindex = int32(sa.Ifindex)
552 rx := (*[4]byte)(unsafe.Pointer(&sa.RxID))
553 for i := 0; i < 4; i++ {
554 sa.raw.Addr[i] = rx[i]
555 }
556 tx := (*[4]byte)(unsafe.Pointer(&sa.TxID))
557 for i := 0; i < 4; i++ {
558 sa.raw.Addr[i+4] = tx[i]
559 }
560 return unsafe.Pointer(&sa.raw), SizeofSockaddrCAN, nil
561}
562
563// SockaddrCANJ1939 implements the Sockaddr interface for AF_CAN using J1939
564// protocol (https://en.wikipedia.org/wiki/SAE_J1939). For more information
565// on the purposes of the fields, check the official linux kernel documentation
566// available here: https://www.kernel.org/doc/Documentation/networking/j1939.rst
567type SockaddrCANJ1939 struct {
568 Ifindex int
569 Name uint64
570 PGN uint32
571 Addr uint8
572 raw RawSockaddrCAN
573}
574
575func (sa *SockaddrCANJ1939) sockaddr() (unsafe.Pointer, _Socklen, error) {
576 if sa.Ifindex < 0 || sa.Ifindex > 0x7fffffff {
577 return nil, 0, EINVAL
578 }
579 sa.raw.Family = AF_CAN
580 sa.raw.Ifindex = int32(sa.Ifindex)
581 n := (*[8]byte)(unsafe.Pointer(&sa.Name))
582 for i := 0; i < 8; i++ {
583 sa.raw.Addr[i] = n[i]
584 }
585 p := (*[4]byte)(unsafe.Pointer(&sa.PGN))
586 for i := 0; i < 4; i++ {
587 sa.raw.Addr[i+8] = p[i]
588 }
589 sa.raw.Addr[12] = sa.Addr
590 return unsafe.Pointer(&sa.raw), SizeofSockaddrCAN, nil
591}
592
593// SockaddrALG implements the Sockaddr interface for AF_ALG type sockets.
594// SockaddrALG enables userspace access to the Linux kernel's cryptography
595// subsystem. The Type and Name fields specify which type of hash or cipher
596// should be used with a given socket.
597//
598// To create a file descriptor that provides access to a hash or cipher, both
599// Bind and Accept must be used. Once the setup process is complete, input
600// data can be written to the socket, processed by the kernel, and then read
601// back as hash output or ciphertext.
602//
603// Here is an example of using an AF_ALG socket with SHA1 hashing.
604// The initial socket setup process is as follows:
605//
606// // Open a socket to perform SHA1 hashing.
607// fd, _ := unix.Socket(unix.AF_ALG, unix.SOCK_SEQPACKET, 0)
608// addr := &unix.SockaddrALG{Type: "hash", Name: "sha1"}
609// unix.Bind(fd, addr)
610// // Note: unix.Accept does not work at this time; must invoke accept()
611// // manually using unix.Syscall.
612// hashfd, _, _ := unix.Syscall(unix.SYS_ACCEPT, uintptr(fd), 0, 0)
613//
614// Once a file descriptor has been returned from Accept, it may be used to
615// perform SHA1 hashing. The descriptor is not safe for concurrent use, but
616// may be re-used repeatedly with subsequent Write and Read operations.
617//
618// When hashing a small byte slice or string, a single Write and Read may
619// be used:
620//
621// // Assume hashfd is already configured using the setup process.
622// hash := os.NewFile(hashfd, "sha1")
623// // Hash an input string and read the results. Each Write discards
624// // previous hash state. Read always reads the current state.
625// b := make([]byte, 20)
626// for i := 0; i < 2; i++ {
627// io.WriteString(hash, "Hello, world.")
628// hash.Read(b)
629// fmt.Println(hex.EncodeToString(b))
630// }
631// // Output:
632// // 2ae01472317d1935a84797ec1983ae243fc6aa28
633// // 2ae01472317d1935a84797ec1983ae243fc6aa28
634//
635// For hashing larger byte slices, or byte streams such as those read from
636// a file or socket, use Sendto with MSG_MORE to instruct the kernel to update
637// the hash digest instead of creating a new one for a given chunk and finalizing it.
638//
639// // Assume hashfd and addr are already configured using the setup process.
640// hash := os.NewFile(hashfd, "sha1")
641// // Hash the contents of a file.
642// f, _ := os.Open("/tmp/linux-4.10-rc7.tar.xz")
643// b := make([]byte, 4096)
644// for {
645// n, err := f.Read(b)
646// if err == io.EOF {
647// break
648// }
649// unix.Sendto(hashfd, b[:n], unix.MSG_MORE, addr)
650// }
651// hash.Read(b)
652// fmt.Println(hex.EncodeToString(b))
653// // Output: 85cdcad0c06eef66f805ecce353bec9accbeecc5
654//
655// For more information, see: http://www.chronox.de/crypto-API/crypto/userspace-if.html.
656type SockaddrALG struct {
657 Type string
658 Name string
659 Feature uint32
660 Mask uint32
661 raw RawSockaddrALG
662}
663
664func (sa *SockaddrALG) sockaddr() (unsafe.Pointer, _Socklen, error) {
665 // Leave room for NUL byte terminator.
666 if len(sa.Type) > 13 {
667 return nil, 0, EINVAL
668 }
669 if len(sa.Name) > 63 {
670 return nil, 0, EINVAL
671 }
672
673 sa.raw.Family = AF_ALG
674 sa.raw.Feat = sa.Feature
675 sa.raw.Mask = sa.Mask
676
677 typ, err := ByteSliceFromString(sa.Type)
678 if err != nil {
679 return nil, 0, err
680 }
681 name, err := ByteSliceFromString(sa.Name)
682 if err != nil {
683 return nil, 0, err
684 }
685
686 copy(sa.raw.Type[:], typ)
687 copy(sa.raw.Name[:], name)
688
689 return unsafe.Pointer(&sa.raw), SizeofSockaddrALG, nil
690}
691
692// SockaddrVM implements the Sockaddr interface for AF_VSOCK type sockets.
693// SockaddrVM provides access to Linux VM sockets: a mechanism that enables
694// bidirectional communication between a hypervisor and its guest virtual
695// machines.
696type SockaddrVM struct {
697 // CID and Port specify a context ID and port address for a VM socket.
698 // Guests have a unique CID, and hosts may have a well-known CID of:
699 // - VMADDR_CID_HYPERVISOR: refers to the hypervisor process.
700 // - VMADDR_CID_LOCAL: refers to local communication (loopback).
701 // - VMADDR_CID_HOST: refers to other processes on the host.
702 CID uint32
703 Port uint32
704 Flags uint8
705 raw RawSockaddrVM
706}
707
708func (sa *SockaddrVM) sockaddr() (unsafe.Pointer, _Socklen, error) {
709 sa.raw.Family = AF_VSOCK
710 sa.raw.Port = sa.Port
711 sa.raw.Cid = sa.CID
712 sa.raw.Flags = sa.Flags
713
714 return unsafe.Pointer(&sa.raw), SizeofSockaddrVM, nil
715}
716
717type SockaddrXDP struct {
718 Flags uint16
719 Ifindex uint32
720 QueueID uint32
721 SharedUmemFD uint32
722 raw RawSockaddrXDP
723}
724
725func (sa *SockaddrXDP) sockaddr() (unsafe.Pointer, _Socklen, error) {
726 sa.raw.Family = AF_XDP
727 sa.raw.Flags = sa.Flags
728 sa.raw.Ifindex = sa.Ifindex
729 sa.raw.Queue_id = sa.QueueID
730 sa.raw.Shared_umem_fd = sa.SharedUmemFD
731
732 return unsafe.Pointer(&sa.raw), SizeofSockaddrXDP, nil
733}
734
735// This constant mirrors the #define of PX_PROTO_OE in
736// linux/if_pppox.h. We're defining this by hand here instead of
737// autogenerating through mkerrors.sh because including
738// linux/if_pppox.h causes some declaration conflicts with other
739// includes (linux/if_pppox.h includes linux/in.h, which conflicts
740// with netinet/in.h). Given that we only need a single zero constant
741// out of that file, it's cleaner to just define it by hand here.
742const px_proto_oe = 0
743
744type SockaddrPPPoE struct {
745 SID uint16
746 Remote []byte
747 Dev string
748 raw RawSockaddrPPPoX
749}
750
751func (sa *SockaddrPPPoE) sockaddr() (unsafe.Pointer, _Socklen, error) {
752 if len(sa.Remote) != 6 {
753 return nil, 0, EINVAL
754 }
755 if len(sa.Dev) > IFNAMSIZ-1 {
756 return nil, 0, EINVAL
757 }
758
759 *(*uint16)(unsafe.Pointer(&sa.raw[0])) = AF_PPPOX
760 // This next field is in host-endian byte order. We can't use the
761 // same unsafe pointer cast as above, because this value is not
762 // 32-bit aligned and some architectures don't allow unaligned
763 // access.
764 //
765 // However, the value of px_proto_oe is 0, so we can use
766 // encoding/binary helpers to write the bytes without worrying
767 // about the ordering.
768 binary.BigEndian.PutUint32(sa.raw[2:6], px_proto_oe)
769 // This field is deliberately big-endian, unlike the previous
770 // one. The kernel expects SID to be in network byte order.
771 binary.BigEndian.PutUint16(sa.raw[6:8], sa.SID)
772 copy(sa.raw[8:14], sa.Remote)
773 for i := 14; i < 14+IFNAMSIZ; i++ {
774 sa.raw[i] = 0
775 }
776 copy(sa.raw[14:], sa.Dev)
777 return unsafe.Pointer(&sa.raw), SizeofSockaddrPPPoX, nil
778}
779
780// SockaddrTIPC implements the Sockaddr interface for AF_TIPC type sockets.
781// For more information on TIPC, see: http://tipc.sourceforge.net/.
782type SockaddrTIPC struct {
783 // Scope is the publication scopes when binding service/service range.
784 // Should be set to TIPC_CLUSTER_SCOPE or TIPC_NODE_SCOPE.
785 Scope int
786
787 // Addr is the type of address used to manipulate a socket. Addr must be
788 // one of:
789 // - *TIPCSocketAddr: "id" variant in the C addr union
790 // - *TIPCServiceRange: "nameseq" variant in the C addr union
791 // - *TIPCServiceName: "name" variant in the C addr union
792 //
793 // If nil, EINVAL will be returned when the structure is used.
794 Addr TIPCAddr
795
796 raw RawSockaddrTIPC
797}
798
799// TIPCAddr is implemented by types that can be used as an address for
800// SockaddrTIPC. It is only implemented by *TIPCSocketAddr, *TIPCServiceRange,
801// and *TIPCServiceName.
802type TIPCAddr interface {
803 tipcAddrtype() uint8
804 tipcAddr() [12]byte
805}
806
807func (sa *TIPCSocketAddr) tipcAddr() [12]byte {
808 var out [12]byte
809 copy(out[:], (*(*[unsafe.Sizeof(TIPCSocketAddr{})]byte)(unsafe.Pointer(sa)))[:])
810 return out
811}
812
813func (sa *TIPCSocketAddr) tipcAddrtype() uint8 { return TIPC_SOCKET_ADDR }
814
815func (sa *TIPCServiceRange) tipcAddr() [12]byte {
816 var out [12]byte
817 copy(out[:], (*(*[unsafe.Sizeof(TIPCServiceRange{})]byte)(unsafe.Pointer(sa)))[:])
818 return out
819}
820
821func (sa *TIPCServiceRange) tipcAddrtype() uint8 { return TIPC_SERVICE_RANGE }
822
823func (sa *TIPCServiceName) tipcAddr() [12]byte {
824 var out [12]byte
825 copy(out[:], (*(*[unsafe.Sizeof(TIPCServiceName{})]byte)(unsafe.Pointer(sa)))[:])
826 return out
827}
828
829func (sa *TIPCServiceName) tipcAddrtype() uint8 { return TIPC_SERVICE_ADDR }
830
831func (sa *SockaddrTIPC) sockaddr() (unsafe.Pointer, _Socklen, error) {
832 if sa.Addr == nil {
833 return nil, 0, EINVAL
834 }
835
836 sa.raw.Family = AF_TIPC
837 sa.raw.Scope = int8(sa.Scope)
838 sa.raw.Addrtype = sa.Addr.tipcAddrtype()
839 sa.raw.Addr = sa.Addr.tipcAddr()
840
841 return unsafe.Pointer(&sa.raw), SizeofSockaddrTIPC, nil
842}
843
844// SockaddrL2TPIP implements the Sockaddr interface for IPPROTO_L2TP/AF_INET sockets.
845type SockaddrL2TPIP struct {
846 Addr [4]byte
847 ConnId uint32
848 raw RawSockaddrL2TPIP
849}
850
851func (sa *SockaddrL2TPIP) sockaddr() (unsafe.Pointer, _Socklen, error) {
852 sa.raw.Family = AF_INET
853 sa.raw.Conn_id = sa.ConnId
854 for i := 0; i < len(sa.Addr); i++ {
855 sa.raw.Addr[i] = sa.Addr[i]
856 }
857 return unsafe.Pointer(&sa.raw), SizeofSockaddrL2TPIP, nil
858}
859
860// SockaddrL2TPIP6 implements the Sockaddr interface for IPPROTO_L2TP/AF_INET6 sockets.
861type SockaddrL2TPIP6 struct {
862 Addr [16]byte
863 ZoneId uint32
864 ConnId uint32
865 raw RawSockaddrL2TPIP6
866}
867
868func (sa *SockaddrL2TPIP6) sockaddr() (unsafe.Pointer, _Socklen, error) {
869 sa.raw.Family = AF_INET6
870 sa.raw.Conn_id = sa.ConnId
871 sa.raw.Scope_id = sa.ZoneId
872 for i := 0; i < len(sa.Addr); i++ {
873 sa.raw.Addr[i] = sa.Addr[i]
874 }
875 return unsafe.Pointer(&sa.raw), SizeofSockaddrL2TPIP6, nil
876}
877
878// SockaddrIUCV implements the Sockaddr interface for AF_IUCV sockets.
879type SockaddrIUCV struct {
880 UserID string
881 Name string
882 raw RawSockaddrIUCV
883}
884
885func (sa *SockaddrIUCV) sockaddr() (unsafe.Pointer, _Socklen, error) {
886 sa.raw.Family = AF_IUCV
887 // These are EBCDIC encoded by the kernel, but we still need to pad them
888 // with blanks. Initializing with blanks allows the caller to feed in either
889 // a padded or an unpadded string.
890 for i := 0; i < 8; i++ {
891 sa.raw.Nodeid[i] = ' '
892 sa.raw.User_id[i] = ' '
893 sa.raw.Name[i] = ' '
894 }
895 if len(sa.UserID) > 8 || len(sa.Name) > 8 {
896 return nil, 0, EINVAL
897 }
898 for i, b := range []byte(sa.UserID[:]) {
899 sa.raw.User_id[i] = int8(b)
900 }
901 for i, b := range []byte(sa.Name[:]) {
902 sa.raw.Name[i] = int8(b)
903 }
904 return unsafe.Pointer(&sa.raw), SizeofSockaddrIUCV, nil
905}
906
907var socketProtocol = func(fd int) (int, error) {
908 return GetsockoptInt(fd, SOL_SOCKET, SO_PROTOCOL)
909}
910
911func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) {
912 switch rsa.Addr.Family {
913 case AF_NETLINK:
914 pp := (*RawSockaddrNetlink)(unsafe.Pointer(rsa))
915 sa := new(SockaddrNetlink)
916 sa.Family = pp.Family
917 sa.Pad = pp.Pad
918 sa.Pid = pp.Pid
919 sa.Groups = pp.Groups
920 return sa, nil
921
922 case AF_PACKET:
923 pp := (*RawSockaddrLinklayer)(unsafe.Pointer(rsa))
924 sa := new(SockaddrLinklayer)
925 sa.Protocol = pp.Protocol
926 sa.Ifindex = int(pp.Ifindex)
927 sa.Hatype = pp.Hatype
928 sa.Pkttype = pp.Pkttype
929 sa.Halen = pp.Halen
930 for i := 0; i < len(sa.Addr); i++ {
931 sa.Addr[i] = pp.Addr[i]
932 }
933 return sa, nil
934
935 case AF_UNIX:
936 pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
937 sa := new(SockaddrUnix)
938 if pp.Path[0] == 0 {
939 // "Abstract" Unix domain socket.
940 // Rewrite leading NUL as @ for textual display.
941 // (This is the standard convention.)
942 // Not friendly to overwrite in place,
943 // but the callers below don't care.
944 pp.Path[0] = '@'
945 }
946
947 // Assume path ends at NUL.
948 // This is not technically the Linux semantics for
949 // abstract Unix domain sockets--they are supposed
950 // to be uninterpreted fixed-size binary blobs--but
951 // everyone uses this convention.
952 n := 0
953 for n < len(pp.Path) && pp.Path[n] != 0 {
954 n++
955 }
956 bytes := (*[len(pp.Path)]byte)(unsafe.Pointer(&pp.Path[0]))[0:n]
957 sa.Name = string(bytes)
958 return sa, nil
959
960 case AF_INET:
961 proto, err := socketProtocol(fd)
962 if err != nil {
963 return nil, err
964 }
965
966 switch proto {
967 case IPPROTO_L2TP:
968 pp := (*RawSockaddrL2TPIP)(unsafe.Pointer(rsa))
969 sa := new(SockaddrL2TPIP)
970 sa.ConnId = pp.Conn_id
971 for i := 0; i < len(sa.Addr); i++ {
972 sa.Addr[i] = pp.Addr[i]
973 }
974 return sa, nil
975 default:
976 pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa))
977 sa := new(SockaddrInet4)
978 p := (*[2]byte)(unsafe.Pointer(&pp.Port))
979 sa.Port = int(p[0])<<8 + int(p[1])
980 for i := 0; i < len(sa.Addr); i++ {
981 sa.Addr[i] = pp.Addr[i]
982 }
983 return sa, nil
984 }
985
986 case AF_INET6:
987 proto, err := socketProtocol(fd)
988 if err != nil {
989 return nil, err
990 }
991
992 switch proto {
993 case IPPROTO_L2TP:
994 pp := (*RawSockaddrL2TPIP6)(unsafe.Pointer(rsa))
995 sa := new(SockaddrL2TPIP6)
996 sa.ConnId = pp.Conn_id
997 sa.ZoneId = pp.Scope_id
998 for i := 0; i < len(sa.Addr); i++ {
999 sa.Addr[i] = pp.Addr[i]
1000 }
1001 return sa, nil
1002 default:
1003 pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa))
1004 sa := new(SockaddrInet6)
1005 p := (*[2]byte)(unsafe.Pointer(&pp.Port))
1006 sa.Port = int(p[0])<<8 + int(p[1])
1007 sa.ZoneId = pp.Scope_id
1008 for i := 0; i < len(sa.Addr); i++ {
1009 sa.Addr[i] = pp.Addr[i]
1010 }
1011 return sa, nil
1012 }
1013
1014 case AF_VSOCK:
1015 pp := (*RawSockaddrVM)(unsafe.Pointer(rsa))
1016 sa := &SockaddrVM{
1017 CID: pp.Cid,
1018 Port: pp.Port,
1019 Flags: pp.Flags,
1020 }
1021 return sa, nil
1022 case AF_BLUETOOTH:
1023 proto, err := socketProtocol(fd)
1024 if err != nil {
1025 return nil, err
1026 }
1027 // only BTPROTO_L2CAP and BTPROTO_RFCOMM can accept connections
1028 switch proto {
1029 case BTPROTO_L2CAP:
1030 pp := (*RawSockaddrL2)(unsafe.Pointer(rsa))
1031 sa := &SockaddrL2{
1032 PSM: pp.Psm,
1033 CID: pp.Cid,
1034 Addr: pp.Bdaddr,
1035 AddrType: pp.Bdaddr_type,
1036 }
1037 return sa, nil
1038 case BTPROTO_RFCOMM:
1039 pp := (*RawSockaddrRFCOMM)(unsafe.Pointer(rsa))
1040 sa := &SockaddrRFCOMM{
1041 Channel: pp.Channel,
1042 Addr: pp.Bdaddr,
1043 }
1044 return sa, nil
1045 }
1046 case AF_XDP:
1047 pp := (*RawSockaddrXDP)(unsafe.Pointer(rsa))
1048 sa := &SockaddrXDP{
1049 Flags: pp.Flags,
1050 Ifindex: pp.Ifindex,
1051 QueueID: pp.Queue_id,
1052 SharedUmemFD: pp.Shared_umem_fd,
1053 }
1054 return sa, nil
1055 case AF_PPPOX:
1056 pp := (*RawSockaddrPPPoX)(unsafe.Pointer(rsa))
1057 if binary.BigEndian.Uint32(pp[2:6]) != px_proto_oe {
1058 return nil, EINVAL
1059 }
1060 sa := &SockaddrPPPoE{
1061 SID: binary.BigEndian.Uint16(pp[6:8]),
1062 Remote: pp[8:14],
1063 }
1064 for i := 14; i < 14+IFNAMSIZ; i++ {
1065 if pp[i] == 0 {
1066 sa.Dev = string(pp[14:i])
1067 break
1068 }
1069 }
1070 return sa, nil
1071 case AF_TIPC:
1072 pp := (*RawSockaddrTIPC)(unsafe.Pointer(rsa))
1073
1074 sa := &SockaddrTIPC{
1075 Scope: int(pp.Scope),
1076 }
1077
1078 // Determine which union variant is present in pp.Addr by checking
1079 // pp.Addrtype.
1080 switch pp.Addrtype {
1081 case TIPC_SERVICE_RANGE:
1082 sa.Addr = (*TIPCServiceRange)(unsafe.Pointer(&pp.Addr))
1083 case TIPC_SERVICE_ADDR:
1084 sa.Addr = (*TIPCServiceName)(unsafe.Pointer(&pp.Addr))
1085 case TIPC_SOCKET_ADDR:
1086 sa.Addr = (*TIPCSocketAddr)(unsafe.Pointer(&pp.Addr))
1087 default:
1088 return nil, EINVAL
1089 }
1090
1091 return sa, nil
1092 case AF_IUCV:
1093 pp := (*RawSockaddrIUCV)(unsafe.Pointer(rsa))
1094
1095 var user [8]byte
1096 var name [8]byte
1097
1098 for i := 0; i < 8; i++ {
1099 user[i] = byte(pp.User_id[i])
1100 name[i] = byte(pp.Name[i])
1101 }
1102
1103 sa := &SockaddrIUCV{
1104 UserID: string(user[:]),
1105 Name: string(name[:]),
1106 }
1107 return sa, nil
1108
1109 case AF_CAN:
1110 proto, err := socketProtocol(fd)
1111 if err != nil {
1112 return nil, err
1113 }
1114
1115 pp := (*RawSockaddrCAN)(unsafe.Pointer(rsa))
1116
1117 switch proto {
1118 case CAN_J1939:
1119 sa := &SockaddrCANJ1939{
1120 Ifindex: int(pp.Ifindex),
1121 }
1122 name := (*[8]byte)(unsafe.Pointer(&sa.Name))
1123 for i := 0; i < 8; i++ {
1124 name[i] = pp.Addr[i]
1125 }
1126 pgn := (*[4]byte)(unsafe.Pointer(&sa.PGN))
1127 for i := 0; i < 4; i++ {
1128 pgn[i] = pp.Addr[i+8]
1129 }
1130 addr := (*[1]byte)(unsafe.Pointer(&sa.Addr))
1131 addr[0] = pp.Addr[12]
1132 return sa, nil
1133 default:
1134 sa := &SockaddrCAN{
1135 Ifindex: int(pp.Ifindex),
1136 }
1137 rx := (*[4]byte)(unsafe.Pointer(&sa.RxID))
1138 for i := 0; i < 4; i++ {
1139 rx[i] = pp.Addr[i]
1140 }
1141 tx := (*[4]byte)(unsafe.Pointer(&sa.TxID))
1142 for i := 0; i < 4; i++ {
1143 tx[i] = pp.Addr[i+4]
1144 }
1145 return sa, nil
1146 }
1147 }
1148 return nil, EAFNOSUPPORT
1149}
1150
1151func Accept(fd int) (nfd int, sa Sockaddr, err error) {
1152 var rsa RawSockaddrAny
1153 var len _Socklen = SizeofSockaddrAny
1154 nfd, err = accept(fd, &rsa, &len)
1155 if err != nil {
1156 return
1157 }
1158 sa, err = anyToSockaddr(fd, &rsa)
1159 if err != nil {
1160 Close(nfd)
1161 nfd = 0
1162 }
1163 return
1164}
1165
1166func Accept4(fd int, flags int) (nfd int, sa Sockaddr, err error) {
1167 var rsa RawSockaddrAny
1168 var len _Socklen = SizeofSockaddrAny
1169 nfd, err = accept4(fd, &rsa, &len, flags)
1170 if err != nil {
1171 return
1172 }
1173 if len > SizeofSockaddrAny {
1174 panic("RawSockaddrAny too small")
1175 }
1176 sa, err = anyToSockaddr(fd, &rsa)
1177 if err != nil {
1178 Close(nfd)
1179 nfd = 0
1180 }
1181 return
1182}
1183
1184func Getsockname(fd int) (sa Sockaddr, err error) {
1185 var rsa RawSockaddrAny
1186 var len _Socklen = SizeofSockaddrAny
1187 if err = getsockname(fd, &rsa, &len); err != nil {
1188 return
1189 }
1190 return anyToSockaddr(fd, &rsa)
1191}
1192
1193func GetsockoptIPMreqn(fd, level, opt int) (*IPMreqn, error) {
1194 var value IPMreqn
1195 vallen := _Socklen(SizeofIPMreqn)
1196 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
1197 return &value, err
1198}
1199
1200func GetsockoptUcred(fd, level, opt int) (*Ucred, error) {
1201 var value Ucred
1202 vallen := _Socklen(SizeofUcred)
1203 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
1204 return &value, err
1205}
1206
1207func GetsockoptTCPInfo(fd, level, opt int) (*TCPInfo, error) {
1208 var value TCPInfo
1209 vallen := _Socklen(SizeofTCPInfo)
1210 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
1211 return &value, err
1212}
1213
1214// GetsockoptString returns the string value of the socket option opt for the
1215// socket associated with fd at the given socket level.
1216func GetsockoptString(fd, level, opt int) (string, error) {
1217 buf := make([]byte, 256)
1218 vallen := _Socklen(len(buf))
1219 err := getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen)
1220 if err != nil {
1221 if err == ERANGE {
1222 buf = make([]byte, vallen)
1223 err = getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen)
1224 }
1225 if err != nil {
1226 return "", err
1227 }
1228 }
1229 return string(buf[:vallen-1]), nil
1230}
1231
1232func GetsockoptTpacketStats(fd, level, opt int) (*TpacketStats, error) {
1233 var value TpacketStats
1234 vallen := _Socklen(SizeofTpacketStats)
1235 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
1236 return &value, err
1237}
1238
1239func GetsockoptTpacketStatsV3(fd, level, opt int) (*TpacketStatsV3, error) {
1240 var value TpacketStatsV3
1241 vallen := _Socklen(SizeofTpacketStatsV3)
1242 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
1243 return &value, err
1244}
1245
1246func SetsockoptIPMreqn(fd, level, opt int, mreq *IPMreqn) (err error) {
1247 return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq))
1248}
1249
1250func SetsockoptPacketMreq(fd, level, opt int, mreq *PacketMreq) error {
1251 return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq))
1252}
1253
1254// SetsockoptSockFprog attaches a classic BPF or an extended BPF program to a
1255// socket to filter incoming packets. See 'man 7 socket' for usage information.
1256func SetsockoptSockFprog(fd, level, opt int, fprog *SockFprog) error {
1257 return setsockopt(fd, level, opt, unsafe.Pointer(fprog), unsafe.Sizeof(*fprog))
1258}
1259
1260func SetsockoptCanRawFilter(fd, level, opt int, filter []CanFilter) error {
1261 var p unsafe.Pointer
1262 if len(filter) > 0 {
1263 p = unsafe.Pointer(&filter[0])
1264 }
1265 return setsockopt(fd, level, opt, p, uintptr(len(filter)*SizeofCanFilter))
1266}
1267
1268func SetsockoptTpacketReq(fd, level, opt int, tp *TpacketReq) error {
1269 return setsockopt(fd, level, opt, unsafe.Pointer(tp), unsafe.Sizeof(*tp))
1270}
1271
1272func SetsockoptTpacketReq3(fd, level, opt int, tp *TpacketReq3) error {
1273 return setsockopt(fd, level, opt, unsafe.Pointer(tp), unsafe.Sizeof(*tp))
1274}
1275
1276// Keyctl Commands (http://man7.org/linux/man-pages/man2/keyctl.2.html)
1277
1278// KeyctlInt calls keyctl commands in which each argument is an int.
1279// These commands are KEYCTL_REVOKE, KEYCTL_CHOWN, KEYCTL_CLEAR, KEYCTL_LINK,
1280// KEYCTL_UNLINK, KEYCTL_NEGATE, KEYCTL_SET_REQKEY_KEYRING, KEYCTL_SET_TIMEOUT,
1281// KEYCTL_ASSUME_AUTHORITY, KEYCTL_SESSION_TO_PARENT, KEYCTL_REJECT,
1282// KEYCTL_INVALIDATE, and KEYCTL_GET_PERSISTENT.
1283//sys KeyctlInt(cmd int, arg2 int, arg3 int, arg4 int, arg5 int) (ret int, err error) = SYS_KEYCTL
1284
1285// KeyctlBuffer calls keyctl commands in which the third and fourth
1286// arguments are a buffer and its length, respectively.
1287// These commands are KEYCTL_UPDATE, KEYCTL_READ, and KEYCTL_INSTANTIATE.
1288//sys KeyctlBuffer(cmd int, arg2 int, buf []byte, arg5 int) (ret int, err error) = SYS_KEYCTL
1289
1290// KeyctlString calls keyctl commands which return a string.
1291// These commands are KEYCTL_DESCRIBE and KEYCTL_GET_SECURITY.
1292func KeyctlString(cmd int, id int) (string, error) {
1293 // We must loop as the string data may change in between the syscalls.
1294 // We could allocate a large buffer here to reduce the chance that the
1295 // syscall needs to be called twice; however, this is unnecessary as
1296 // the performance loss is negligible.
1297 var buffer []byte
1298 for {
1299 // Try to fill the buffer with data
1300 length, err := KeyctlBuffer(cmd, id, buffer, 0)
1301 if err != nil {
1302 return "", err
1303 }
1304
1305 // Check if the data was written
1306 if length <= len(buffer) {
1307 // Exclude the null terminator
1308 return string(buffer[:length-1]), nil
1309 }
1310
1311 // Make a bigger buffer if needed
1312 buffer = make([]byte, length)
1313 }
1314}
1315
1316// Keyctl commands with special signatures.
1317
1318// KeyctlGetKeyringID implements the KEYCTL_GET_KEYRING_ID command.
1319// See the full documentation at:
1320// http://man7.org/linux/man-pages/man3/keyctl_get_keyring_ID.3.html
1321func KeyctlGetKeyringID(id int, create bool) (ringid int, err error) {
1322 createInt := 0
1323 if create {
1324 createInt = 1
1325 }
1326 return KeyctlInt(KEYCTL_GET_KEYRING_ID, id, createInt, 0, 0)
1327}
1328
1329// KeyctlSetperm implements the KEYCTL_SETPERM command. The perm value is the
1330// key handle permission mask as described in the "keyctl setperm" section of
1331// http://man7.org/linux/man-pages/man1/keyctl.1.html.
1332// See the full documentation at:
1333// http://man7.org/linux/man-pages/man3/keyctl_setperm.3.html
1334func KeyctlSetperm(id int, perm uint32) error {
1335 _, err := KeyctlInt(KEYCTL_SETPERM, id, int(perm), 0, 0)
1336 return err
1337}
1338
1339//sys keyctlJoin(cmd int, arg2 string) (ret int, err error) = SYS_KEYCTL
1340
1341// KeyctlJoinSessionKeyring implements the KEYCTL_JOIN_SESSION_KEYRING command.
1342// See the full documentation at:
1343// http://man7.org/linux/man-pages/man3/keyctl_join_session_keyring.3.html
1344func KeyctlJoinSessionKeyring(name string) (ringid int, err error) {
1345 return keyctlJoin(KEYCTL_JOIN_SESSION_KEYRING, name)
1346}
1347
1348//sys keyctlSearch(cmd int, arg2 int, arg3 string, arg4 string, arg5 int) (ret int, err error) = SYS_KEYCTL
1349
1350// KeyctlSearch implements the KEYCTL_SEARCH command.
1351// See the full documentation at:
1352// http://man7.org/linux/man-pages/man3/keyctl_search.3.html
1353func KeyctlSearch(ringid int, keyType, description string, destRingid int) (id int, err error) {
1354 return keyctlSearch(KEYCTL_SEARCH, ringid, keyType, description, destRingid)
1355}
1356
1357//sys keyctlIOV(cmd int, arg2 int, payload []Iovec, arg5 int) (err error) = SYS_KEYCTL
1358
1359// KeyctlInstantiateIOV implements the KEYCTL_INSTANTIATE_IOV command. This
1360// command is similar to KEYCTL_INSTANTIATE, except that the payload is a slice
1361// of Iovec (each of which represents a buffer) instead of a single buffer.
1362// See the full documentation at:
1363// http://man7.org/linux/man-pages/man3/keyctl_instantiate_iov.3.html
1364func KeyctlInstantiateIOV(id int, payload []Iovec, ringid int) error {
1365 return keyctlIOV(KEYCTL_INSTANTIATE_IOV, id, payload, ringid)
1366}
1367
1368//sys keyctlDH(cmd int, arg2 *KeyctlDHParams, buf []byte) (ret int, err error) = SYS_KEYCTL
1369
1370// KeyctlDHCompute implements the KEYCTL_DH_COMPUTE command. This command
1371// computes a Diffie-Hellman shared secret based on the provide params. The
1372// secret is written to the provided buffer and the returned size is the number
1373// of bytes written (returning an error if there is insufficient space in the
1374// buffer). If a nil buffer is passed in, this function returns the minimum
1375// buffer length needed to store the appropriate data. Note that this differs
1376// from KEYCTL_READ's behavior which always returns the requested payload size.
1377// See the full documentation at:
1378// http://man7.org/linux/man-pages/man3/keyctl_dh_compute.3.html
1379func KeyctlDHCompute(params *KeyctlDHParams, buffer []byte) (size int, err error) {
1380 return keyctlDH(KEYCTL_DH_COMPUTE, params, buffer)
1381}
1382
1383// KeyctlRestrictKeyring implements the KEYCTL_RESTRICT_KEYRING command. This
1384// command limits the set of keys that can be linked to the keyring, regardless
1385// of keyring permissions. The command requires the "setattr" permission.
1386//
1387// When called with an empty keyType the command locks the keyring, preventing
1388// any further keys from being linked to the keyring.
1389//
1390// The "asymmetric" keyType defines restrictions requiring key payloads to be
1391// DER encoded X.509 certificates signed by keys in another keyring. Restrictions
1392// for "asymmetric" include "builtin_trusted", "builtin_and_secondary_trusted",
1393// "key_or_keyring:<key>", and "key_or_keyring:<key>:chain".
1394//
1395// As of Linux 4.12, only the "asymmetric" keyType defines type-specific
1396// restrictions.
1397//
1398// See the full documentation at:
1399// http://man7.org/linux/man-pages/man3/keyctl_restrict_keyring.3.html
1400// http://man7.org/linux/man-pages/man2/keyctl.2.html
1401func KeyctlRestrictKeyring(ringid int, keyType string, restriction string) error {
1402 if keyType == "" {
1403 return keyctlRestrictKeyring(KEYCTL_RESTRICT_KEYRING, ringid)
1404 }
1405 return keyctlRestrictKeyringByType(KEYCTL_RESTRICT_KEYRING, ringid, keyType, restriction)
1406}
1407
1408//sys keyctlRestrictKeyringByType(cmd int, arg2 int, keyType string, restriction string) (err error) = SYS_KEYCTL
1409//sys keyctlRestrictKeyring(cmd int, arg2 int) (err error) = SYS_KEYCTL
1410
1411func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) {
1412 var msg Msghdr
1413 var rsa RawSockaddrAny
1414 msg.Name = (*byte)(unsafe.Pointer(&rsa))
1415 msg.Namelen = uint32(SizeofSockaddrAny)
1416 var iov Iovec
1417 if len(p) > 0 {
1418 iov.Base = &p[0]
1419 iov.SetLen(len(p))
1420 }
1421 var dummy byte
1422 if len(oob) > 0 {
1423 if len(p) == 0 {
1424 var sockType int
1425 sockType, err = GetsockoptInt(fd, SOL_SOCKET, SO_TYPE)
1426 if err != nil {
1427 return
1428 }
1429 // receive at least one normal byte
1430 if sockType != SOCK_DGRAM {
1431 iov.Base = &dummy
1432 iov.SetLen(1)
1433 }
1434 }
1435 msg.Control = &oob[0]
1436 msg.SetControllen(len(oob))
1437 }
1438 msg.Iov = &iov
1439 msg.Iovlen = 1
1440 if n, err = recvmsg(fd, &msg, flags); err != nil {
1441 return
1442 }
1443 oobn = int(msg.Controllen)
1444 recvflags = int(msg.Flags)
1445 // source address is only specified if the socket is unconnected
1446 if rsa.Addr.Family != AF_UNSPEC {
1447 from, err = anyToSockaddr(fd, &rsa)
1448 }
1449 return
1450}
1451
1452func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) {
1453 _, err = SendmsgN(fd, p, oob, to, flags)
1454 return
1455}
1456
1457func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) {
1458 var ptr unsafe.Pointer
1459 var salen _Socklen
1460 if to != nil {
1461 var err error
1462 ptr, salen, err = to.sockaddr()
1463 if err != nil {
1464 return 0, err
1465 }
1466 }
1467 var msg Msghdr
1468 msg.Name = (*byte)(ptr)
1469 msg.Namelen = uint32(salen)
1470 var iov Iovec
1471 if len(p) > 0 {
1472 iov.Base = &p[0]
1473 iov.SetLen(len(p))
1474 }
1475 var dummy byte
1476 if len(oob) > 0 {
1477 if len(p) == 0 {
1478 var sockType int
1479 sockType, err = GetsockoptInt(fd, SOL_SOCKET, SO_TYPE)
1480 if err != nil {
1481 return 0, err
1482 }
1483 // send at least one normal byte
1484 if sockType != SOCK_DGRAM {
1485 iov.Base = &dummy
1486 iov.SetLen(1)
1487 }
1488 }
1489 msg.Control = &oob[0]
1490 msg.SetControllen(len(oob))
1491 }
1492 msg.Iov = &iov
1493 msg.Iovlen = 1
1494 if n, err = sendmsg(fd, &msg, flags); err != nil {
1495 return 0, err
1496 }
1497 if len(oob) > 0 && len(p) == 0 {
1498 n = 0
1499 }
1500 return n, nil
1501}
1502
1503// BindToDevice binds the socket associated with fd to device.
1504func BindToDevice(fd int, device string) (err error) {
1505 return SetsockoptString(fd, SOL_SOCKET, SO_BINDTODEVICE, device)
1506}
1507
1508//sys ptrace(request int, pid int, addr uintptr, data uintptr) (err error)
1509
1510func ptracePeek(req int, pid int, addr uintptr, out []byte) (count int, err error) {
1511 // The peek requests are machine-size oriented, so we wrap it
1512 // to retrieve arbitrary-length data.
1513
1514 // The ptrace syscall differs from glibc's ptrace.
1515 // Peeks returns the word in *data, not as the return value.
1516
1517 var buf [SizeofPtr]byte
1518
1519 // Leading edge. PEEKTEXT/PEEKDATA don't require aligned
1520 // access (PEEKUSER warns that it might), but if we don't
1521 // align our reads, we might straddle an unmapped page
1522 // boundary and not get the bytes leading up to the page
1523 // boundary.
1524 n := 0
1525 if addr%SizeofPtr != 0 {
1526 err = ptrace(req, pid, addr-addr%SizeofPtr, uintptr(unsafe.Pointer(&buf[0])))
1527 if err != nil {
1528 return 0, err
1529 }
1530 n += copy(out, buf[addr%SizeofPtr:])
1531 out = out[n:]
1532 }
1533
1534 // Remainder.
1535 for len(out) > 0 {
1536 // We use an internal buffer to guarantee alignment.
1537 // It's not documented if this is necessary, but we're paranoid.
1538 err = ptrace(req, pid, addr+uintptr(n), uintptr(unsafe.Pointer(&buf[0])))
1539 if err != nil {
1540 return n, err
1541 }
1542 copied := copy(out, buf[0:])
1543 n += copied
1544 out = out[copied:]
1545 }
1546
1547 return n, nil
1548}
1549
1550func PtracePeekText(pid int, addr uintptr, out []byte) (count int, err error) {
1551 return ptracePeek(PTRACE_PEEKTEXT, pid, addr, out)
1552}
1553
1554func PtracePeekData(pid int, addr uintptr, out []byte) (count int, err error) {
1555 return ptracePeek(PTRACE_PEEKDATA, pid, addr, out)
1556}
1557
1558func PtracePeekUser(pid int, addr uintptr, out []byte) (count int, err error) {
1559 return ptracePeek(PTRACE_PEEKUSR, pid, addr, out)
1560}
1561
1562func ptracePoke(pokeReq int, peekReq int, pid int, addr uintptr, data []byte) (count int, err error) {
1563 // As for ptracePeek, we need to align our accesses to deal
1564 // with the possibility of straddling an invalid page.
1565
1566 // Leading edge.
1567 n := 0
1568 if addr%SizeofPtr != 0 {
1569 var buf [SizeofPtr]byte
1570 err = ptrace(peekReq, pid, addr-addr%SizeofPtr, uintptr(unsafe.Pointer(&buf[0])))
1571 if err != nil {
1572 return 0, err
1573 }
1574 n += copy(buf[addr%SizeofPtr:], data)
1575 word := *((*uintptr)(unsafe.Pointer(&buf[0])))
1576 err = ptrace(pokeReq, pid, addr-addr%SizeofPtr, word)
1577 if err != nil {
1578 return 0, err
1579 }
1580 data = data[n:]
1581 }
1582
1583 // Interior.
1584 for len(data) > SizeofPtr {
1585 word := *((*uintptr)(unsafe.Pointer(&data[0])))
1586 err = ptrace(pokeReq, pid, addr+uintptr(n), word)
1587 if err != nil {
1588 return n, err
1589 }
1590 n += SizeofPtr
1591 data = data[SizeofPtr:]
1592 }
1593
1594 // Trailing edge.
1595 if len(data) > 0 {
1596 var buf [SizeofPtr]byte
1597 err = ptrace(peekReq, pid, addr+uintptr(n), uintptr(unsafe.Pointer(&buf[0])))
1598 if err != nil {
1599 return n, err
1600 }
1601 copy(buf[0:], data)
1602 word := *((*uintptr)(unsafe.Pointer(&buf[0])))
1603 err = ptrace(pokeReq, pid, addr+uintptr(n), word)
1604 if err != nil {
1605 return n, err
1606 }
1607 n += len(data)
1608 }
1609
1610 return n, nil
1611}
1612
1613func PtracePokeText(pid int, addr uintptr, data []byte) (count int, err error) {
1614 return ptracePoke(PTRACE_POKETEXT, PTRACE_PEEKTEXT, pid, addr, data)
1615}
1616
1617func PtracePokeData(pid int, addr uintptr, data []byte) (count int, err error) {
1618 return ptracePoke(PTRACE_POKEDATA, PTRACE_PEEKDATA, pid, addr, data)
1619}
1620
1621func PtracePokeUser(pid int, addr uintptr, data []byte) (count int, err error) {
1622 return ptracePoke(PTRACE_POKEUSR, PTRACE_PEEKUSR, pid, addr, data)
1623}
1624
1625func PtraceGetRegs(pid int, regsout *PtraceRegs) (err error) {
1626 return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout)))
1627}
1628
1629func PtraceSetRegs(pid int, regs *PtraceRegs) (err error) {
1630 return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs)))
1631}
1632
1633func PtraceSetOptions(pid int, options int) (err error) {
1634 return ptrace(PTRACE_SETOPTIONS, pid, 0, uintptr(options))
1635}
1636
1637func PtraceGetEventMsg(pid int) (msg uint, err error) {
1638 var data _C_long
1639 err = ptrace(PTRACE_GETEVENTMSG, pid, 0, uintptr(unsafe.Pointer(&data)))
1640 msg = uint(data)
1641 return
1642}
1643
1644func PtraceCont(pid int, signal int) (err error) {
1645 return ptrace(PTRACE_CONT, pid, 0, uintptr(signal))
1646}
1647
1648func PtraceSyscall(pid int, signal int) (err error) {
1649 return ptrace(PTRACE_SYSCALL, pid, 0, uintptr(signal))
1650}
1651
1652func PtraceSingleStep(pid int) (err error) { return ptrace(PTRACE_SINGLESTEP, pid, 0, 0) }
1653
1654func PtraceInterrupt(pid int) (err error) { return ptrace(PTRACE_INTERRUPT, pid, 0, 0) }
1655
1656func PtraceAttach(pid int) (err error) { return ptrace(PTRACE_ATTACH, pid, 0, 0) }
1657
1658func PtraceSeize(pid int) (err error) { return ptrace(PTRACE_SEIZE, pid, 0, 0) }
1659
1660func PtraceDetach(pid int) (err error) { return ptrace(PTRACE_DETACH, pid, 0, 0) }
1661
1662//sys reboot(magic1 uint, magic2 uint, cmd int, arg string) (err error)
1663
1664func Reboot(cmd int) (err error) {
1665 return reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, cmd, "")
1666}
1667
1668func direntIno(buf []byte) (uint64, bool) {
1669 return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino))
1670}
1671
1672func direntReclen(buf []byte) (uint64, bool) {
1673 return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))
1674}
1675
1676func direntNamlen(buf []byte) (uint64, bool) {
1677 reclen, ok := direntReclen(buf)
1678 if !ok {
1679 return 0, false
1680 }
1681 return reclen - uint64(unsafe.Offsetof(Dirent{}.Name)), true
1682}
1683
1684//sys mount(source string, target string, fstype string, flags uintptr, data *byte) (err error)
1685
1686func Mount(source string, target string, fstype string, flags uintptr, data string) (err error) {
1687 // Certain file systems get rather angry and EINVAL if you give
1688 // them an empty string of data, rather than NULL.
1689 if data == "" {
1690 return mount(source, target, fstype, flags, nil)
1691 }
1692 datap, err := BytePtrFromString(data)
1693 if err != nil {
1694 return err
1695 }
1696 return mount(source, target, fstype, flags, datap)
1697}
1698
1699func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
1700 if raceenabled {
1701 raceReleaseMerge(unsafe.Pointer(&ioSync))
1702 }
1703 return sendfile(outfd, infd, offset, count)
1704}
1705
1706// Sendto
1707// Recvfrom
1708// Socketpair
1709
1710/*
1711 * Direct access
1712 */
1713//sys Acct(path string) (err error)
1714//sys AddKey(keyType string, description string, payload []byte, ringid int) (id int, err error)
1715//sys Adjtimex(buf *Timex) (state int, err error)
1716//sysnb Capget(hdr *CapUserHeader, data *CapUserData) (err error)
1717//sysnb Capset(hdr *CapUserHeader, data *CapUserData) (err error)
1718//sys Chdir(path string) (err error)
1719//sys Chroot(path string) (err error)
1720//sys ClockGetres(clockid int32, res *Timespec) (err error)
1721//sys ClockGettime(clockid int32, time *Timespec) (err error)
1722//sys ClockNanosleep(clockid int32, flags int, request *Timespec, remain *Timespec) (err error)
1723//sys Close(fd int) (err error)
1724//sys CloseRange(first uint, last uint, flags uint) (err error)
1725//sys CopyFileRange(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int, err error)
1726//sys DeleteModule(name string, flags int) (err error)
1727//sys Dup(oldfd int) (fd int, err error)
1728
1729func Dup2(oldfd, newfd int) error {
1730 // Android O and newer blocks dup2; riscv and arm64 don't implement dup2.
1731 if runtime.GOOS == "android" || runtime.GOARCH == "riscv64" || runtime.GOARCH == "arm64" {
1732 return Dup3(oldfd, newfd, 0)
1733 }
1734 return dup2(oldfd, newfd)
1735}
1736
1737//sys Dup3(oldfd int, newfd int, flags int) (err error)
1738//sysnb EpollCreate1(flag int) (fd int, err error)
1739//sysnb EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error)
1740//sys Eventfd(initval uint, flags int) (fd int, err error) = SYS_EVENTFD2
1741//sys Exit(code int) = SYS_EXIT_GROUP
1742//sys Fallocate(fd int, mode uint32, off int64, len int64) (err error)
1743//sys Fchdir(fd int) (err error)
1744//sys Fchmod(fd int, mode uint32) (err error)
1745//sys Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error)
1746//sys Fdatasync(fd int) (err error)
1747//sys Fgetxattr(fd int, attr string, dest []byte) (sz int, err error)
1748//sys FinitModule(fd int, params string, flags int) (err error)
1749//sys Flistxattr(fd int, dest []byte) (sz int, err error)
1750//sys Flock(fd int, how int) (err error)
1751//sys Fremovexattr(fd int, attr string) (err error)
1752//sys Fsetxattr(fd int, attr string, dest []byte, flags int) (err error)
1753//sys Fsync(fd int) (err error)
1754//sys Getdents(fd int, buf []byte) (n int, err error) = SYS_GETDENTS64
1755//sysnb Getpgid(pid int) (pgid int, err error)
1756
1757func Getpgrp() (pid int) {
1758 pid, _ = Getpgid(0)
1759 return
1760}
1761
1762//sysnb Getpid() (pid int)
1763//sysnb Getppid() (ppid int)
1764//sys Getpriority(which int, who int) (prio int, err error)
1765//sys Getrandom(buf []byte, flags int) (n int, err error)
1766//sysnb Getrusage(who int, rusage *Rusage) (err error)
1767//sysnb Getsid(pid int) (sid int, err error)
1768//sysnb Gettid() (tid int)
1769//sys Getxattr(path string, attr string, dest []byte) (sz int, err error)
1770//sys InitModule(moduleImage []byte, params string) (err error)
1771//sys InotifyAddWatch(fd int, pathname string, mask uint32) (watchdesc int, err error)
1772//sysnb InotifyInit1(flags int) (fd int, err error)
1773//sysnb InotifyRmWatch(fd int, watchdesc uint32) (success int, err error)
1774//sysnb Kill(pid int, sig syscall.Signal) (err error)
1775//sys Klogctl(typ int, buf []byte) (n int, err error) = SYS_SYSLOG
1776//sys Lgetxattr(path string, attr string, dest []byte) (sz int, err error)
1777//sys Listxattr(path string, dest []byte) (sz int, err error)
1778//sys Llistxattr(path string, dest []byte) (sz int, err error)
1779//sys Lremovexattr(path string, attr string) (err error)
1780//sys Lsetxattr(path string, attr string, data []byte, flags int) (err error)
1781//sys MemfdCreate(name string, flags int) (fd int, err error)
1782//sys Mkdirat(dirfd int, path string, mode uint32) (err error)
1783//sys Mknodat(dirfd int, path string, mode uint32, dev int) (err error)
1784//sys Nanosleep(time *Timespec, leftover *Timespec) (err error)
1785//sys PerfEventOpen(attr *PerfEventAttr, pid int, cpu int, groupFd int, flags int) (fd int, err error)
1786//sys PivotRoot(newroot string, putold string) (err error) = SYS_PIVOT_ROOT
1787//sysnb prlimit(pid int, resource int, newlimit *Rlimit, old *Rlimit) (err error) = SYS_PRLIMIT64
1788//sys Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error)
1789//sys Pselect(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timespec, sigmask *Sigset_t) (n int, err error) = SYS_PSELECT6
1790//sys read(fd int, p []byte) (n int, err error)
1791//sys Removexattr(path string, attr string) (err error)
1792//sys Renameat2(olddirfd int, oldpath string, newdirfd int, newpath string, flags uint) (err error)
1793//sys RequestKey(keyType string, description string, callback string, destRingid int) (id int, err error)
1794//sys Setdomainname(p []byte) (err error)
1795//sys Sethostname(p []byte) (err error)
1796//sysnb Setpgid(pid int, pgid int) (err error)
1797//sysnb Setsid() (pid int, err error)
1798//sysnb Settimeofday(tv *Timeval) (err error)
1799//sys Setns(fd int, nstype int) (err error)
1800
1801// PrctlRetInt performs a prctl operation specified by option and further
1802// optional arguments arg2 through arg5 depending on option. It returns a
1803// non-negative integer that is returned by the prctl syscall.
1804func PrctlRetInt(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (int, error) {
1805 ret, _, err := Syscall6(SYS_PRCTL, uintptr(option), uintptr(arg2), uintptr(arg3), uintptr(arg4), uintptr(arg5), 0)
1806 if err != 0 {
1807 return 0, err
1808 }
1809 return int(ret), nil
1810}
1811
1812// issue 1435.
1813// On linux Setuid and Setgid only affects the current thread, not the process.
1814// This does not match what most callers expect so we must return an error
1815// here rather than letting the caller think that the call succeeded.
1816
1817func Setuid(uid int) (err error) {
1818 return EOPNOTSUPP
1819}
1820
1821func Setgid(uid int) (err error) {
1822 return EOPNOTSUPP
1823}
1824
1825// SetfsgidRetGid sets fsgid for current thread and returns previous fsgid set.
1826// setfsgid(2) will return a non-nil error only if its caller lacks CAP_SETUID capability.
1827// If the call fails due to other reasons, current fsgid will be returned.
1828func SetfsgidRetGid(gid int) (int, error) {
1829 return setfsgid(gid)
1830}
1831
1832// SetfsuidRetUid sets fsuid for current thread and returns previous fsuid set.
1833// setfsgid(2) will return a non-nil error only if its caller lacks CAP_SETUID capability
1834// If the call fails due to other reasons, current fsuid will be returned.
1835func SetfsuidRetUid(uid int) (int, error) {
1836 return setfsuid(uid)
1837}
1838
1839func Setfsgid(gid int) error {
1840 _, err := setfsgid(gid)
1841 return err
1842}
1843
1844func Setfsuid(uid int) error {
1845 _, err := setfsuid(uid)
1846 return err
1847}
1848
1849func Signalfd(fd int, sigmask *Sigset_t, flags int) (newfd int, err error) {
1850 return signalfd(fd, sigmask, _C__NSIG/8, flags)
1851}
1852
1853//sys Setpriority(which int, who int, prio int) (err error)
1854//sys Setxattr(path string, attr string, data []byte, flags int) (err error)
1855//sys signalfd(fd int, sigmask *Sigset_t, maskSize uintptr, flags int) (newfd int, err error) = SYS_SIGNALFD4
1856//sys Statx(dirfd int, path string, flags int, mask int, stat *Statx_t) (err error)
1857//sys Sync()
1858//sys Syncfs(fd int) (err error)
1859//sysnb Sysinfo(info *Sysinfo_t) (err error)
1860//sys Tee(rfd int, wfd int, len int, flags int) (n int64, err error)
1861//sysnb TimerfdCreate(clockid int, flags int) (fd int, err error)
1862//sysnb TimerfdGettime(fd int, currValue *ItimerSpec) (err error)
1863//sysnb TimerfdSettime(fd int, flags int, newValue *ItimerSpec, oldValue *ItimerSpec) (err error)
1864//sysnb Tgkill(tgid int, tid int, sig syscall.Signal) (err error)
1865//sysnb Times(tms *Tms) (ticks uintptr, err error)
1866//sysnb Umask(mask int) (oldmask int)
1867//sysnb Uname(buf *Utsname) (err error)
1868//sys Unmount(target string, flags int) (err error) = SYS_UMOUNT2
1869//sys Unshare(flags int) (err error)
1870//sys write(fd int, p []byte) (n int, err error)
1871//sys exitThread(code int) (err error) = SYS_EXIT
1872//sys readlen(fd int, p *byte, np int) (n int, err error) = SYS_READ
1873//sys writelen(fd int, p *byte, np int) (n int, err error) = SYS_WRITE
1874//sys readv(fd int, iovs []Iovec) (n int, err error) = SYS_READV
1875//sys writev(fd int, iovs []Iovec) (n int, err error) = SYS_WRITEV
1876//sys preadv(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err error) = SYS_PREADV
1877//sys pwritev(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err error) = SYS_PWRITEV
1878//sys preadv2(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr, flags int) (n int, err error) = SYS_PREADV2
1879//sys pwritev2(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr, flags int) (n int, err error) = SYS_PWRITEV2
1880
1881func bytes2iovec(bs [][]byte) []Iovec {
1882 iovecs := make([]Iovec, len(bs))
1883 for i, b := range bs {
1884 iovecs[i].SetLen(len(b))
1885 if len(b) > 0 {
1886 iovecs[i].Base = &b[0]
1887 } else {
1888 iovecs[i].Base = (*byte)(unsafe.Pointer(&_zero))
1889 }
1890 }
1891 return iovecs
1892}
1893
1894// offs2lohi splits offs into its lower and upper unsigned long. On 64-bit
1895// systems, hi will always be 0. On 32-bit systems, offs will be split in half.
1896// preadv/pwritev chose this calling convention so they don't need to add a
1897// padding-register for alignment on ARM.
1898func offs2lohi(offs int64) (lo, hi uintptr) {
1899 return uintptr(offs), uintptr(uint64(offs) >> SizeofLong)
1900}
1901
1902func Readv(fd int, iovs [][]byte) (n int, err error) {
1903 iovecs := bytes2iovec(iovs)
1904 n, err = readv(fd, iovecs)
1905 readvRacedetect(iovecs, n, err)
1906 return n, err
1907}
1908
1909func Preadv(fd int, iovs [][]byte, offset int64) (n int, err error) {
1910 iovecs := bytes2iovec(iovs)
1911 lo, hi := offs2lohi(offset)
1912 n, err = preadv(fd, iovecs, lo, hi)
1913 readvRacedetect(iovecs, n, err)
1914 return n, err
1915}
1916
1917func Preadv2(fd int, iovs [][]byte, offset int64, flags int) (n int, err error) {
1918 iovecs := bytes2iovec(iovs)
1919 lo, hi := offs2lohi(offset)
1920 n, err = preadv2(fd, iovecs, lo, hi, flags)
1921 readvRacedetect(iovecs, n, err)
1922 return n, err
1923}
1924
1925func readvRacedetect(iovecs []Iovec, n int, err error) {
1926 if !raceenabled {
1927 return
1928 }
1929 for i := 0; n > 0 && i < len(iovecs); i++ {
1930 m := int(iovecs[i].Len)
1931 if m > n {
1932 m = n
1933 }
1934 n -= m
1935 if m > 0 {
1936 raceWriteRange(unsafe.Pointer(iovecs[i].Base), m)
1937 }
1938 }
1939 if err == nil {
1940 raceAcquire(unsafe.Pointer(&ioSync))
1941 }
1942}
1943
1944func Writev(fd int, iovs [][]byte) (n int, err error) {
1945 iovecs := bytes2iovec(iovs)
1946 if raceenabled {
1947 raceReleaseMerge(unsafe.Pointer(&ioSync))
1948 }
1949 n, err = writev(fd, iovecs)
1950 writevRacedetect(iovecs, n)
1951 return n, err
1952}
1953
1954func Pwritev(fd int, iovs [][]byte, offset int64) (n int, err error) {
1955 iovecs := bytes2iovec(iovs)
1956 if raceenabled {
1957 raceReleaseMerge(unsafe.Pointer(&ioSync))
1958 }
1959 lo, hi := offs2lohi(offset)
1960 n, err = pwritev(fd, iovecs, lo, hi)
1961 writevRacedetect(iovecs, n)
1962 return n, err
1963}
1964
1965func Pwritev2(fd int, iovs [][]byte, offset int64, flags int) (n int, err error) {
1966 iovecs := bytes2iovec(iovs)
1967 if raceenabled {
1968 raceReleaseMerge(unsafe.Pointer(&ioSync))
1969 }
1970 lo, hi := offs2lohi(offset)
1971 n, err = pwritev2(fd, iovecs, lo, hi, flags)
1972 writevRacedetect(iovecs, n)
1973 return n, err
1974}
1975
1976func writevRacedetect(iovecs []Iovec, n int) {
1977 if !raceenabled {
1978 return
1979 }
1980 for i := 0; n > 0 && i < len(iovecs); i++ {
1981 m := int(iovecs[i].Len)
1982 if m > n {
1983 m = n
1984 }
1985 n -= m
1986 if m > 0 {
1987 raceReadRange(unsafe.Pointer(iovecs[i].Base), m)
1988 }
1989 }
1990}
1991
1992// mmap varies by architecture; see syscall_linux_*.go.
1993//sys munmap(addr uintptr, length uintptr) (err error)
1994
1995var mapper = &mmapper{
1996 active: make(map[*byte][]byte),
1997 mmap: mmap,
1998 munmap: munmap,
1999}
2000
2001func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) {
2002 return mapper.Mmap(fd, offset, length, prot, flags)
2003}
2004
2005func Munmap(b []byte) (err error) {
2006 return mapper.Munmap(b)
2007}
2008
2009//sys Madvise(b []byte, advice int) (err error)
2010//sys Mprotect(b []byte, prot int) (err error)
2011//sys Mlock(b []byte) (err error)
2012//sys Mlockall(flags int) (err error)
2013//sys Msync(b []byte, flags int) (err error)
2014//sys Munlock(b []byte) (err error)
2015//sys Munlockall() (err error)
2016
2017// Vmsplice splices user pages from a slice of Iovecs into a pipe specified by fd,
2018// using the specified flags.
2019func Vmsplice(fd int, iovs []Iovec, flags int) (int, error) {
2020 var p unsafe.Pointer
2021 if len(iovs) > 0 {
2022 p = unsafe.Pointer(&iovs[0])
2023 }
2024
2025 n, _, errno := Syscall6(SYS_VMSPLICE, uintptr(fd), uintptr(p), uintptr(len(iovs)), uintptr(flags), 0, 0)
2026 if errno != 0 {
2027 return 0, syscall.Errno(errno)
2028 }
2029
2030 return int(n), nil
2031}
2032
2033func isGroupMember(gid int) bool {
2034 groups, err := Getgroups()
2035 if err != nil {
2036 return false
2037 }
2038
2039 for _, g := range groups {
2040 if g == gid {
2041 return true
2042 }
2043 }
2044 return false
2045}
2046
2047//sys faccessat(dirfd int, path string, mode uint32) (err error)
2048//sys Faccessat2(dirfd int, path string, mode uint32, flags int) (err error)
2049
2050func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
2051 if flags == 0 {
2052 return faccessat(dirfd, path, mode)
2053 }
2054
2055 if err := Faccessat2(dirfd, path, mode, flags); err != ENOSYS && err != EPERM {
2056 return err
2057 }
2058
2059 // The Linux kernel faccessat system call does not take any flags.
2060 // The glibc faccessat implements the flags itself; see
2061 // https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/unix/sysv/linux/faccessat.c;hb=HEAD
2062 // Because people naturally expect syscall.Faccessat to act
2063 // like C faccessat, we do the same.
2064
2065 if flags & ^(AT_SYMLINK_NOFOLLOW|AT_EACCESS) != 0 {
2066 return EINVAL
2067 }
2068
2069 var st Stat_t
2070 if err := Fstatat(dirfd, path, &st, flags&AT_SYMLINK_NOFOLLOW); err != nil {
2071 return err
2072 }
2073
2074 mode &= 7
2075 if mode == 0 {
2076 return nil
2077 }
2078
2079 var uid int
2080 if flags&AT_EACCESS != 0 {
2081 uid = Geteuid()
2082 } else {
2083 uid = Getuid()
2084 }
2085
2086 if uid == 0 {
2087 if mode&1 == 0 {
2088 // Root can read and write any file.
2089 return nil
2090 }
2091 if st.Mode&0111 != 0 {
2092 // Root can execute any file that anybody can execute.
2093 return nil
2094 }
2095 return EACCES
2096 }
2097
2098 var fmode uint32
2099 if uint32(uid) == st.Uid {
2100 fmode = (st.Mode >> 6) & 7
2101 } else {
2102 var gid int
2103 if flags&AT_EACCESS != 0 {
2104 gid = Getegid()
2105 } else {
2106 gid = Getgid()
2107 }
2108
2109 if uint32(gid) == st.Gid || isGroupMember(gid) {
2110 fmode = (st.Mode >> 3) & 7
2111 } else {
2112 fmode = st.Mode & 7
2113 }
2114 }
2115
2116 if fmode&mode == mode {
2117 return nil
2118 }
2119
2120 return EACCES
2121}
2122
2123//sys nameToHandleAt(dirFD int, pathname string, fh *fileHandle, mountID *_C_int, flags int) (err error) = SYS_NAME_TO_HANDLE_AT
2124//sys openByHandleAt(mountFD int, fh *fileHandle, flags int) (fd int, err error) = SYS_OPEN_BY_HANDLE_AT
2125
2126// fileHandle is the argument to nameToHandleAt and openByHandleAt. We
2127// originally tried to generate it via unix/linux/types.go with "type
2128// fileHandle C.struct_file_handle" but that generated empty structs
2129// for mips64 and mips64le. Instead, hard code it for now (it's the
2130// same everywhere else) until the mips64 generator issue is fixed.
2131type fileHandle struct {
2132 Bytes uint32
2133 Type int32
2134}
2135
2136// FileHandle represents the C struct file_handle used by
2137// name_to_handle_at (see NameToHandleAt) and open_by_handle_at (see
2138// OpenByHandleAt).
2139type FileHandle struct {
2140 *fileHandle
2141}
2142
2143// NewFileHandle constructs a FileHandle.
2144func NewFileHandle(handleType int32, handle []byte) FileHandle {
2145 const hdrSize = unsafe.Sizeof(fileHandle{})
2146 buf := make([]byte, hdrSize+uintptr(len(handle)))
2147 copy(buf[hdrSize:], handle)
2148 fh := (*fileHandle)(unsafe.Pointer(&buf[0]))
2149 fh.Type = handleType
2150 fh.Bytes = uint32(len(handle))
2151 return FileHandle{fh}
2152}
2153
2154func (fh *FileHandle) Size() int { return int(fh.fileHandle.Bytes) }
2155func (fh *FileHandle) Type() int32 { return fh.fileHandle.Type }
2156func (fh *FileHandle) Bytes() []byte {
2157 n := fh.Size()
2158 if n == 0 {
2159 return nil
2160 }
2161 return (*[1 << 30]byte)(unsafe.Pointer(uintptr(unsafe.Pointer(&fh.fileHandle.Type)) + 4))[:n:n]
2162}
2163
2164// NameToHandleAt wraps the name_to_handle_at system call; it obtains
2165// a handle for a path name.
2166func NameToHandleAt(dirfd int, path string, flags int) (handle FileHandle, mountID int, err error) {
2167 var mid _C_int
2168 // Try first with a small buffer, assuming the handle will
2169 // only be 32 bytes.
2170 size := uint32(32 + unsafe.Sizeof(fileHandle{}))
2171 didResize := false
2172 for {
2173 buf := make([]byte, size)
2174 fh := (*fileHandle)(unsafe.Pointer(&buf[0]))
2175 fh.Bytes = size - uint32(unsafe.Sizeof(fileHandle{}))
2176 err = nameToHandleAt(dirfd, path, fh, &mid, flags)
2177 if err == EOVERFLOW {
2178 if didResize {
2179 // We shouldn't need to resize more than once
2180 return
2181 }
2182 didResize = true
2183 size = fh.Bytes + uint32(unsafe.Sizeof(fileHandle{}))
2184 continue
2185 }
2186 if err != nil {
2187 return
2188 }
2189 return FileHandle{fh}, int(mid), nil
2190 }
2191}
2192
2193// OpenByHandleAt wraps the open_by_handle_at system call; it opens a
2194// file via a handle as previously returned by NameToHandleAt.
2195func OpenByHandleAt(mountFD int, handle FileHandle, flags int) (fd int, err error) {
2196 return openByHandleAt(mountFD, handle.fileHandle, flags)
2197}
2198
2199// Klogset wraps the sys_syslog system call; it sets console_loglevel to
2200// the value specified by arg and passes a dummy pointer to bufp.
2201func Klogset(typ int, arg int) (err error) {
2202 var p unsafe.Pointer
2203 _, _, errno := Syscall(SYS_SYSLOG, uintptr(typ), uintptr(p), uintptr(arg))
2204 if errno != 0 {
2205 return errnoErr(errno)
2206 }
2207 return nil
2208}
2209
2210// RemoteIovec is Iovec with the pointer replaced with an integer.
2211// It is used for ProcessVMReadv and ProcessVMWritev, where the pointer
2212// refers to a location in a different process' address space, which
2213// would confuse the Go garbage collector.
2214type RemoteIovec struct {
2215 Base uintptr
2216 Len int
2217}
2218
2219//sys ProcessVMReadv(pid int, localIov []Iovec, remoteIov []RemoteIovec, flags uint) (n int, err error) = SYS_PROCESS_VM_READV
2220//sys ProcessVMWritev(pid int, localIov []Iovec, remoteIov []RemoteIovec, flags uint) (n int, err error) = SYS_PROCESS_VM_WRITEV
2221
2222/*
2223 * Unimplemented
2224 */
2225// AfsSyscall
2226// Alarm
2227// ArchPrctl
2228// Brk
2229// ClockNanosleep
2230// ClockSettime
2231// Clone
2232// EpollCtlOld
2233// EpollPwait
2234// EpollWaitOld
2235// Execve
2236// Fork
2237// Futex
2238// GetKernelSyms
2239// GetMempolicy
2240// GetRobustList
2241// GetThreadArea
2242// Getitimer
2243// Getpmsg
2244// IoCancel
2245// IoDestroy
2246// IoGetevents
2247// IoSetup
2248// IoSubmit
2249// IoprioGet
2250// IoprioSet
2251// KexecLoad
2252// LookupDcookie
2253// Mbind
2254// MigratePages
2255// Mincore
2256// ModifyLdt
2257// Mount
2258// MovePages
2259// MqGetsetattr
2260// MqNotify
2261// MqOpen
2262// MqTimedreceive
2263// MqTimedsend
2264// MqUnlink
2265// Mremap
2266// Msgctl
2267// Msgget
2268// Msgrcv
2269// Msgsnd
2270// Nfsservctl
2271// Personality
2272// Pselect6
2273// Ptrace
2274// Putpmsg
2275// Quotactl
2276// Readahead
2277// Readv
2278// RemapFilePages
2279// RestartSyscall
2280// RtSigaction
2281// RtSigpending
2282// RtSigprocmask
2283// RtSigqueueinfo
2284// RtSigreturn
2285// RtSigsuspend
2286// RtSigtimedwait
2287// SchedGetPriorityMax
2288// SchedGetPriorityMin
2289// SchedGetparam
2290// SchedGetscheduler
2291// SchedRrGetInterval
2292// SchedSetparam
2293// SchedYield
2294// Security
2295// Semctl
2296// Semget
2297// Semop
2298// Semtimedop
2299// SetMempolicy
2300// SetRobustList
2301// SetThreadArea
2302// SetTidAddress
2303// Shmat
2304// Shmctl
2305// Shmdt
2306// Shmget
2307// Sigaltstack
2308// Swapoff
2309// Swapon
2310// Sysfs
2311// TimerCreate
2312// TimerDelete
2313// TimerGetoverrun
2314// TimerGettime
2315// TimerSettime
2316// Tkill (obsolete)
2317// Tuxcall
2318// Umount2
2319// Uselib
2320// Utimensat
2321// Vfork
2322// Vhangup
2323// Vserver
2324// Waitid
2325// _Sysctl