cubefs

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

12
package unix
13

14
import (
15
	"encoding/binary"
16
	"strconv"
17
	"syscall"
18
	"time"
19
	"unsafe"
20
)
21

22
/*
23
 * Wrapped
24
 */
25

26
func Access(path string, mode uint32) (err error) {
27
	return Faccessat(AT_FDCWD, path, mode, 0)
28
}
29

30
func Chmod(path string, mode uint32) (err error) {
31
	return Fchmodat(AT_FDCWD, path, mode, 0)
32
}
33

34
func Chown(path string, uid int, gid int) (err error) {
35
	return Fchownat(AT_FDCWD, path, uid, gid, 0)
36
}
37

38
func Creat(path string, mode uint32) (fd int, err error) {
39
	return Open(path, O_CREAT|O_WRONLY|O_TRUNC, mode)
40
}
41

42
func EpollCreate(size int) (fd int, err error) {
43
	if size <= 0 {
44
		return -1, EINVAL
45
	}
46
	return EpollCreate1(0)
47
}
48

49
//sys	FanotifyInit(flags uint, event_f_flags uint) (fd int, err error)
50
//sys	fanotifyMark(fd int, flags uint, mask uint64, dirFd int, pathname *byte) (err error)
51

52
func FanotifyMark(fd int, flags uint, mask uint64, dirFd int, pathname string) (err error) {
53
	if pathname == "" {
54
		return fanotifyMark(fd, flags, mask, dirFd, nil)
55
	}
56
	p, err := BytePtrFromString(pathname)
57
	if err != nil {
58
		return err
59
	}
60
	return fanotifyMark(fd, flags, mask, dirFd, p)
61
}
62

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

65
func Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) {
66
	// Linux fchmodat doesn't support the flags parameter. Mimick glibc's behavior
67
	// and check the flags. Otherwise the mode would be applied to the symlink
68
	// destination which is not what the user expects.
69
	if flags&^AT_SYMLINK_NOFOLLOW != 0 {
70
		return EINVAL
71
	} else if flags&AT_SYMLINK_NOFOLLOW != 0 {
72
		return EOPNOTSUPP
73
	}
74
	return fchmodat(dirfd, path, mode)
75
}
76

77
func InotifyInit() (fd int, err error) {
78
	return InotifyInit1(0)
79
}
80

81
//sys	ioctl(fd int, req uint, arg uintptr) (err error) = SYS_IOCTL
82
//sys	ioctlPtr(fd int, req uint, arg unsafe.Pointer) (err error) = SYS_IOCTL
83

84
// ioctl itself should not be exposed directly, but additional get/set functions
85
// for specific types are permissible. These are defined in ioctl.go and
86
// ioctl_linux.go.
87
//
88
// The third argument to ioctl is often a pointer but sometimes an integer.
89
// Callers should use ioctlPtr when the third argument is a pointer and ioctl
90
// when the third argument is an integer.
91
//
92
// TODO: some existing code incorrectly uses ioctl when it should use ioctlPtr.
93

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

96
func Link(oldpath string, newpath string) (err error) {
97
	return Linkat(AT_FDCWD, oldpath, AT_FDCWD, newpath, 0)
98
}
99

100
func Mkdir(path string, mode uint32) (err error) {
101
	return Mkdirat(AT_FDCWD, path, mode)
102
}
103

104
func Mknod(path string, mode uint32, dev int) (err error) {
105
	return Mknodat(AT_FDCWD, path, mode, dev)
106
}
107

108
func Open(path string, mode int, perm uint32) (fd int, err error) {
109
	return openat(AT_FDCWD, path, mode|O_LARGEFILE, perm)
110
}
111

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

114
func Openat(dirfd int, path string, flags int, mode uint32) (fd int, err error) {
115
	return openat(dirfd, path, flags|O_LARGEFILE, mode)
116
}
117

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

120
func Openat2(dirfd int, path string, how *OpenHow) (fd int, err error) {
121
	return openat2(dirfd, path, how, SizeofOpenHow)
122
}
123

124
func Pipe(p []int) error {
125
	return Pipe2(p, 0)
126
}
127

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

130
func Pipe2(p []int, flags int) error {
131
	if len(p) != 2 {
132
		return EINVAL
133
	}
134
	var pp [2]_C_int
135
	err := pipe2(&pp, flags)
136
	if err == nil {
137
		p[0] = int(pp[0])
138
		p[1] = int(pp[1])
139
	}
140
	return err
141
}
142

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

145
func Ppoll(fds []PollFd, timeout *Timespec, sigmask *Sigset_t) (n int, err error) {
146
	if len(fds) == 0 {
147
		return ppoll(nil, 0, timeout, sigmask)
148
	}
149
	return ppoll(&fds[0], len(fds), timeout, sigmask)
150
}
151

152
func Poll(fds []PollFd, timeout int) (n int, err error) {
153
	var ts *Timespec
154
	if timeout >= 0 {
155
		ts = new(Timespec)
156
		*ts = NsecToTimespec(int64(timeout) * 1e6)
157
	}
158
	return Ppoll(fds, ts, nil)
159
}
160

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

163
func Readlink(path string, buf []byte) (n int, err error) {
164
	return Readlinkat(AT_FDCWD, path, buf)
165
}
166

167
func Rename(oldpath string, newpath string) (err error) {
168
	return Renameat(AT_FDCWD, oldpath, AT_FDCWD, newpath)
169
}
170

171
func Rmdir(path string) error {
172
	return Unlinkat(AT_FDCWD, path, AT_REMOVEDIR)
173
}
174

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

177
func Symlink(oldpath string, newpath string) (err error) {
178
	return Symlinkat(oldpath, AT_FDCWD, newpath)
179
}
180

181
func Unlink(path string) error {
182
	return Unlinkat(AT_FDCWD, path, 0)
183
}
184

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

187
func Utimes(path string, tv []Timeval) error {
188
	if tv == nil {
189
		err := utimensat(AT_FDCWD, path, nil, 0)
190
		if err != ENOSYS {
191
			return err
192
		}
193
		return utimes(path, nil)
194
	}
195
	if len(tv) != 2 {
196
		return EINVAL
197
	}
198
	var ts [2]Timespec
199
	ts[0] = NsecToTimespec(TimevalToNsec(tv[0]))
200
	ts[1] = NsecToTimespec(TimevalToNsec(tv[1]))
201
	err := utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0)
202
	if err != ENOSYS {
203
		return err
204
	}
205
	return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
206
}
207

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

210
func UtimesNano(path string, ts []Timespec) error {
211
	return UtimesNanoAt(AT_FDCWD, path, ts, 0)
212
}
213

214
func UtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) error {
215
	if ts == nil {
216
		return utimensat(dirfd, path, nil, flags)
217
	}
218
	if len(ts) != 2 {
219
		return EINVAL
220
	}
221
	return utimensat(dirfd, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), flags)
222
}
223

224
func Futimesat(dirfd int, path string, tv []Timeval) error {
225
	if tv == nil {
226
		return futimesat(dirfd, path, nil)
227
	}
228
	if len(tv) != 2 {
229
		return EINVAL
230
	}
231
	return futimesat(dirfd, path, (*[2]Timeval)(unsafe.Pointer(&tv[0])))
232
}
233

234
func Futimes(fd int, tv []Timeval) (err error) {
235
	// Believe it or not, this is the best we can do on Linux
236
	// (and is what glibc does).
237
	return Utimes("/proc/self/fd/"+strconv.Itoa(fd), tv)
238
}
239

240
const ImplementsGetwd = true
241

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

244
func Getwd() (wd string, err error) {
245
	var buf [PathMax]byte
246
	n, err := Getcwd(buf[0:])
247
	if err != nil {
248
		return "", err
249
	}
250
	// Getcwd returns the number of bytes written to buf, including the NUL.
251
	if n < 1 || n > len(buf) || buf[n-1] != 0 {
252
		return "", EINVAL
253
	}
254
	// In some cases, Linux can return a path that starts with the
255
	// "(unreachable)" prefix, which can potentially be a valid relative
256
	// path. To work around that, return ENOENT if path is not absolute.
257
	if buf[0] != '/' {
258
		return "", ENOENT
259
	}
260

261
	return string(buf[0 : n-1]), nil
262
}
263

264
func Getgroups() (gids []int, err error) {
265
	n, err := getgroups(0, nil)
266
	if err != nil {
267
		return nil, err
268
	}
269
	if n == 0 {
270
		return nil, nil
271
	}
272

273
	// Sanity check group count. Max is 1<<16 on Linux.
274
	if n < 0 || n > 1<<20 {
275
		return nil, EINVAL
276
	}
277

278
	a := make([]_Gid_t, n)
279
	n, err = getgroups(n, &a[0])
280
	if err != nil {
281
		return nil, err
282
	}
283
	gids = make([]int, n)
284
	for i, v := range a[0:n] {
285
		gids[i] = int(v)
286
	}
287
	return
288
}
289

290
func Setgroups(gids []int) (err error) {
291
	if len(gids) == 0 {
292
		return setgroups(0, nil)
293
	}
294

295
	a := make([]_Gid_t, len(gids))
296
	for i, v := range gids {
297
		a[i] = _Gid_t(v)
298
	}
299
	return setgroups(len(a), &a[0])
300
}
301

302
type WaitStatus uint32
303

304
// Wait status is 7 bits at bottom, either 0 (exited),
305
// 0x7F (stopped), or a signal number that caused an exit.
306
// The 0x80 bit is whether there was a core dump.
307
// An extra number (exit code, signal causing a stop)
308
// is in the high bits. At least that's the idea.
309
// There are various irregularities. For example, the
310
// "continued" status is 0xFFFF, distinguishing itself
311
// from stopped via the core dump bit.
312

313
const (
314
	mask    = 0x7F
315
	core    = 0x80
316
	exited  = 0x00
317
	stopped = 0x7F
318
	shift   = 8
319
)
320

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

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

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

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

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

331
func (w WaitStatus) ExitStatus() int {
332
	if !w.Exited() {
333
		return -1
334
	}
335
	return int(w>>shift) & 0xFF
336
}
337

338
func (w WaitStatus) Signal() syscall.Signal {
339
	if !w.Signaled() {
340
		return -1
341
	}
342
	return syscall.Signal(w & mask)
343
}
344

345
func (w WaitStatus) StopSignal() syscall.Signal {
346
	if !w.Stopped() {
347
		return -1
348
	}
349
	return syscall.Signal(w>>shift) & 0xFF
350
}
351

352
func (w WaitStatus) TrapCause() int {
353
	if w.StopSignal() != SIGTRAP {
354
		return -1
355
	}
356
	return int(w>>shift) >> 8
357
}
358

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

361
func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) {
362
	var status _C_int
363
	wpid, err = wait4(pid, &status, options, rusage)
364
	if wstatus != nil {
365
		*wstatus = WaitStatus(status)
366
	}
367
	return
368
}
369

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

372
func Mkfifo(path string, mode uint32) error {
373
	return Mknod(path, mode|S_IFIFO, 0)
374
}
375

376
func Mkfifoat(dirfd int, path string, mode uint32) error {
377
	return Mknodat(dirfd, path, mode|S_IFIFO, 0)
378
}
379

380
func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) {
381
	if sa.Port < 0 || sa.Port > 0xFFFF {
382
		return nil, 0, EINVAL
383
	}
384
	sa.raw.Family = AF_INET
385
	p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
386
	p[0] = byte(sa.Port >> 8)
387
	p[1] = byte(sa.Port)
388
	sa.raw.Addr = sa.Addr
389
	return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil
390
}
391

392
func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) {
393
	if sa.Port < 0 || sa.Port > 0xFFFF {
394
		return nil, 0, EINVAL
395
	}
396
	sa.raw.Family = AF_INET6
397
	p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port))
398
	p[0] = byte(sa.Port >> 8)
399
	p[1] = byte(sa.Port)
400
	sa.raw.Scope_id = sa.ZoneId
401
	sa.raw.Addr = sa.Addr
402
	return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil
403
}
404

405
func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) {
406
	name := sa.Name
407
	n := len(name)
408
	if n >= len(sa.raw.Path) {
409
		return nil, 0, EINVAL
410
	}
411
	sa.raw.Family = AF_UNIX
412
	for i := 0; i < n; i++ {
413
		sa.raw.Path[i] = int8(name[i])
414
	}
415
	// length is family (uint16), name, NUL.
416
	sl := _Socklen(2)
417
	if n > 0 {
418
		sl += _Socklen(n) + 1
419
	}
420
	if sa.raw.Path[0] == '@' {
421
		sa.raw.Path[0] = 0
422
		// Don't count trailing NUL for abstract address.
423
		sl--
424
	}
425

426
	return unsafe.Pointer(&sa.raw), sl, nil
427
}
428

429
// SockaddrLinklayer implements the Sockaddr interface for AF_PACKET type sockets.
430
type SockaddrLinklayer struct {
431
	Protocol uint16
432
	Ifindex  int
433
	Hatype   uint16
434
	Pkttype  uint8
435
	Halen    uint8
436
	Addr     [8]byte
437
	raw      RawSockaddrLinklayer
438
}
439

440
func (sa *SockaddrLinklayer) sockaddr() (unsafe.Pointer, _Socklen, error) {
441
	if sa.Ifindex < 0 || sa.Ifindex > 0x7fffffff {
442
		return nil, 0, EINVAL
443
	}
444
	sa.raw.Family = AF_PACKET
445
	sa.raw.Protocol = sa.Protocol
446
	sa.raw.Ifindex = int32(sa.Ifindex)
447
	sa.raw.Hatype = sa.Hatype
448
	sa.raw.Pkttype = sa.Pkttype
449
	sa.raw.Halen = sa.Halen
450
	sa.raw.Addr = sa.Addr
451
	return unsafe.Pointer(&sa.raw), SizeofSockaddrLinklayer, nil
452
}
453

454
// SockaddrNetlink implements the Sockaddr interface for AF_NETLINK type sockets.
455
type SockaddrNetlink struct {
456
	Family uint16
457
	Pad    uint16
458
	Pid    uint32
459
	Groups uint32
460
	raw    RawSockaddrNetlink
461
}
462

463
func (sa *SockaddrNetlink) sockaddr() (unsafe.Pointer, _Socklen, error) {
464
	sa.raw.Family = AF_NETLINK
465
	sa.raw.Pad = sa.Pad
466
	sa.raw.Pid = sa.Pid
467
	sa.raw.Groups = sa.Groups
468
	return unsafe.Pointer(&sa.raw), SizeofSockaddrNetlink, nil
469
}
470

471
// SockaddrHCI implements the Sockaddr interface for AF_BLUETOOTH type sockets
472
// using the HCI protocol.
473
type SockaddrHCI struct {
474
	Dev     uint16
475
	Channel uint16
476
	raw     RawSockaddrHCI
477
}
478

479
func (sa *SockaddrHCI) sockaddr() (unsafe.Pointer, _Socklen, error) {
480
	sa.raw.Family = AF_BLUETOOTH
481
	sa.raw.Dev = sa.Dev
482
	sa.raw.Channel = sa.Channel
483
	return unsafe.Pointer(&sa.raw), SizeofSockaddrHCI, nil
484
}
485

486
// SockaddrL2 implements the Sockaddr interface for AF_BLUETOOTH type sockets
487
// using the L2CAP protocol.
488
type SockaddrL2 struct {
489
	PSM      uint16
490
	CID      uint16
491
	Addr     [6]uint8
492
	AddrType uint8
493
	raw      RawSockaddrL2
494
}
495

496
func (sa *SockaddrL2) sockaddr() (unsafe.Pointer, _Socklen, error) {
497
	sa.raw.Family = AF_BLUETOOTH
498
	psm := (*[2]byte)(unsafe.Pointer(&sa.raw.Psm))
499
	psm[0] = byte(sa.PSM)
500
	psm[1] = byte(sa.PSM >> 8)
501
	for i := 0; i < len(sa.Addr); i++ {
502
		sa.raw.Bdaddr[i] = sa.Addr[len(sa.Addr)-1-i]
503
	}
504
	cid := (*[2]byte)(unsafe.Pointer(&sa.raw.Cid))
505
	cid[0] = byte(sa.CID)
506
	cid[1] = byte(sa.CID >> 8)
507
	sa.raw.Bdaddr_type = sa.AddrType
508
	return unsafe.Pointer(&sa.raw), SizeofSockaddrL2, nil
509
}
510

511
// SockaddrRFCOMM implements the Sockaddr interface for AF_BLUETOOTH type sockets
512
// using the RFCOMM protocol.
513
//
514
// Server example:
515
//
516
//	fd, _ := Socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM)
517
//	_ = unix.Bind(fd, &unix.SockaddrRFCOMM{
518
//		Channel: 1,
519
//		Addr:    [6]uint8{0, 0, 0, 0, 0, 0}, // BDADDR_ANY or 00:00:00:00:00:00
520
//	})
521
//	_ = Listen(fd, 1)
522
//	nfd, sa, _ := Accept(fd)
523
//	fmt.Printf("conn addr=%v fd=%d", sa.(*unix.SockaddrRFCOMM).Addr, nfd)
524
//	Read(nfd, buf)
525
//
526
// Client example:
527
//
528
//	fd, _ := Socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM)
529
//	_ = Connect(fd, &SockaddrRFCOMM{
530
//		Channel: 1,
531
//		Addr:    [6]byte{0x11, 0x22, 0x33, 0xaa, 0xbb, 0xcc}, // CC:BB:AA:33:22:11
532
//	})
533
//	Write(fd, []byte(`hello`))
534
type SockaddrRFCOMM struct {
535
	// Addr represents a bluetooth address, byte ordering is little-endian.
536
	Addr [6]uint8
537

538
	// Channel is a designated bluetooth channel, only 1-30 are available for use.
539
	// Since Linux 2.6.7 and further zero value is the first available channel.
540
	Channel uint8
541

542
	raw RawSockaddrRFCOMM
543
}
544

545
func (sa *SockaddrRFCOMM) sockaddr() (unsafe.Pointer, _Socklen, error) {
546
	sa.raw.Family = AF_BLUETOOTH
547
	sa.raw.Channel = sa.Channel
548
	sa.raw.Bdaddr = sa.Addr
549
	return unsafe.Pointer(&sa.raw), SizeofSockaddrRFCOMM, nil
550
}
551

552
// SockaddrCAN implements the Sockaddr interface for AF_CAN type sockets.
553
// The RxID and TxID fields are used for transport protocol addressing in
554
// (CAN_TP16, CAN_TP20, CAN_MCNET, and CAN_ISOTP), they can be left with
555
// zero values for CAN_RAW and CAN_BCM sockets as they have no meaning.
556
//
557
// The SockaddrCAN struct must be bound to the socket file descriptor
558
// using Bind before the CAN socket can be used.
559
//
560
//	// Read one raw CAN frame
561
//	fd, _ := Socket(AF_CAN, SOCK_RAW, CAN_RAW)
562
//	addr := &SockaddrCAN{Ifindex: index}
563
//	Bind(fd, addr)
564
//	frame := make([]byte, 16)
565
//	Read(fd, frame)
566
//
567
// The full SocketCAN documentation can be found in the linux kernel
568
// archives at: https://www.kernel.org/doc/Documentation/networking/can.txt
569
type SockaddrCAN struct {
570
	Ifindex int
571
	RxID    uint32
572
	TxID    uint32
573
	raw     RawSockaddrCAN
574
}
575

576
func (sa *SockaddrCAN) sockaddr() (unsafe.Pointer, _Socklen, error) {
577
	if sa.Ifindex < 0 || sa.Ifindex > 0x7fffffff {
578
		return nil, 0, EINVAL
579
	}
580
	sa.raw.Family = AF_CAN
581
	sa.raw.Ifindex = int32(sa.Ifindex)
582
	rx := (*[4]byte)(unsafe.Pointer(&sa.RxID))
583
	for i := 0; i < 4; i++ {
584
		sa.raw.Addr[i] = rx[i]
585
	}
586
	tx := (*[4]byte)(unsafe.Pointer(&sa.TxID))
587
	for i := 0; i < 4; i++ {
588
		sa.raw.Addr[i+4] = tx[i]
589
	}
590
	return unsafe.Pointer(&sa.raw), SizeofSockaddrCAN, nil
591
}
592

593
// SockaddrCANJ1939 implements the Sockaddr interface for AF_CAN using J1939
594
// protocol (https://en.wikipedia.org/wiki/SAE_J1939). For more information
595
// on the purposes of the fields, check the official linux kernel documentation
596
// available here: https://www.kernel.org/doc/Documentation/networking/j1939.rst
597
type SockaddrCANJ1939 struct {
598
	Ifindex int
599
	Name    uint64
600
	PGN     uint32
601
	Addr    uint8
602
	raw     RawSockaddrCAN
603
}
604

605
func (sa *SockaddrCANJ1939) sockaddr() (unsafe.Pointer, _Socklen, error) {
606
	if sa.Ifindex < 0 || sa.Ifindex > 0x7fffffff {
607
		return nil, 0, EINVAL
608
	}
609
	sa.raw.Family = AF_CAN
610
	sa.raw.Ifindex = int32(sa.Ifindex)
611
	n := (*[8]byte)(unsafe.Pointer(&sa.Name))
612
	for i := 0; i < 8; i++ {
613
		sa.raw.Addr[i] = n[i]
614
	}
615
	p := (*[4]byte)(unsafe.Pointer(&sa.PGN))
616
	for i := 0; i < 4; i++ {
617
		sa.raw.Addr[i+8] = p[i]
618
	}
619
	sa.raw.Addr[12] = sa.Addr
620
	return unsafe.Pointer(&sa.raw), SizeofSockaddrCAN, nil
621
}
622

623
// SockaddrALG implements the Sockaddr interface for AF_ALG type sockets.
624
// SockaddrALG enables userspace access to the Linux kernel's cryptography
625
// subsystem. The Type and Name fields specify which type of hash or cipher
626
// should be used with a given socket.
627
//
628
// To create a file descriptor that provides access to a hash or cipher, both
629
// Bind and Accept must be used. Once the setup process is complete, input
630
// data can be written to the socket, processed by the kernel, and then read
631
// back as hash output or ciphertext.
632
//
633
// Here is an example of using an AF_ALG socket with SHA1 hashing.
634
// The initial socket setup process is as follows:
635
//
636
//	// Open a socket to perform SHA1 hashing.
637
//	fd, _ := unix.Socket(unix.AF_ALG, unix.SOCK_SEQPACKET, 0)
638
//	addr := &unix.SockaddrALG{Type: "hash", Name: "sha1"}
639
//	unix.Bind(fd, addr)
640
//	// Note: unix.Accept does not work at this time; must invoke accept()
641
//	// manually using unix.Syscall.
642
//	hashfd, _, _ := unix.Syscall(unix.SYS_ACCEPT, uintptr(fd), 0, 0)
643
//
644
// Once a file descriptor has been returned from Accept, it may be used to
645
// perform SHA1 hashing. The descriptor is not safe for concurrent use, but
646
// may be re-used repeatedly with subsequent Write and Read operations.
647
//
648
// When hashing a small byte slice or string, a single Write and Read may
649
// be used:
650
//
651
//	// Assume hashfd is already configured using the setup process.
652
//	hash := os.NewFile(hashfd, "sha1")
653
//	// Hash an input string and read the results. Each Write discards
654
//	// previous hash state. Read always reads the current state.
655
//	b := make([]byte, 20)
656
//	for i := 0; i < 2; i++ {
657
//	    io.WriteString(hash, "Hello, world.")
658
//	    hash.Read(b)
659
//	    fmt.Println(hex.EncodeToString(b))
660
//	}
661
//	// Output:
662
//	// 2ae01472317d1935a84797ec1983ae243fc6aa28
663
//	// 2ae01472317d1935a84797ec1983ae243fc6aa28
664
//
665
// For hashing larger byte slices, or byte streams such as those read from
666
// a file or socket, use Sendto with MSG_MORE to instruct the kernel to update
667
// the hash digest instead of creating a new one for a given chunk and finalizing it.
668
//
669
//	// Assume hashfd and addr are already configured using the setup process.
670
//	hash := os.NewFile(hashfd, "sha1")
671
//	// Hash the contents of a file.
672
//	f, _ := os.Open("/tmp/linux-4.10-rc7.tar.xz")
673
//	b := make([]byte, 4096)
674
//	for {
675
//	    n, err := f.Read(b)
676
//	    if err == io.EOF {
677
//	        break
678
//	    }
679
//	    unix.Sendto(hashfd, b[:n], unix.MSG_MORE, addr)
680
//	}
681
//	hash.Read(b)
682
//	fmt.Println(hex.EncodeToString(b))
683
//	// Output: 85cdcad0c06eef66f805ecce353bec9accbeecc5
684
//
685
// For more information, see: http://www.chronox.de/crypto-API/crypto/userspace-if.html.
686
type SockaddrALG struct {
687
	Type    string
688
	Name    string
689
	Feature uint32
690
	Mask    uint32
691
	raw     RawSockaddrALG
692
}
693

694
func (sa *SockaddrALG) sockaddr() (unsafe.Pointer, _Socklen, error) {
695
	// Leave room for NUL byte terminator.
696
	if len(sa.Type) > 13 {
697
		return nil, 0, EINVAL
698
	}
699
	if len(sa.Name) > 63 {
700
		return nil, 0, EINVAL
701
	}
702

703
	sa.raw.Family = AF_ALG
704
	sa.raw.Feat = sa.Feature
705
	sa.raw.Mask = sa.Mask
706

707
	typ, err := ByteSliceFromString(sa.Type)
708
	if err != nil {
709
		return nil, 0, err
710
	}
711
	name, err := ByteSliceFromString(sa.Name)
712
	if err != nil {
713
		return nil, 0, err
714
	}
715

716
	copy(sa.raw.Type[:], typ)
717
	copy(sa.raw.Name[:], name)
718

719
	return unsafe.Pointer(&sa.raw), SizeofSockaddrALG, nil
720
}
721

722
// SockaddrVM implements the Sockaddr interface for AF_VSOCK type sockets.
723
// SockaddrVM provides access to Linux VM sockets: a mechanism that enables
724
// bidirectional communication between a hypervisor and its guest virtual
725
// machines.
726
type SockaddrVM struct {
727
	// CID and Port specify a context ID and port address for a VM socket.
728
	// Guests have a unique CID, and hosts may have a well-known CID of:
729
	//  - VMADDR_CID_HYPERVISOR: refers to the hypervisor process.
730
	//  - VMADDR_CID_LOCAL: refers to local communication (loopback).
731
	//  - VMADDR_CID_HOST: refers to other processes on the host.
732
	CID   uint32
733
	Port  uint32
734
	Flags uint8
735
	raw   RawSockaddrVM
736
}
737

738
func (sa *SockaddrVM) sockaddr() (unsafe.Pointer, _Socklen, error) {
739
	sa.raw.Family = AF_VSOCK
740
	sa.raw.Port = sa.Port
741
	sa.raw.Cid = sa.CID
742
	sa.raw.Flags = sa.Flags
743

744
	return unsafe.Pointer(&sa.raw), SizeofSockaddrVM, nil
745
}
746

747
type SockaddrXDP struct {
748
	Flags        uint16
749
	Ifindex      uint32
750
	QueueID      uint32
751
	SharedUmemFD uint32
752
	raw          RawSockaddrXDP
753
}
754

755
func (sa *SockaddrXDP) sockaddr() (unsafe.Pointer, _Socklen, error) {
756
	sa.raw.Family = AF_XDP
757
	sa.raw.Flags = sa.Flags
758
	sa.raw.Ifindex = sa.Ifindex
759
	sa.raw.Queue_id = sa.QueueID
760
	sa.raw.Shared_umem_fd = sa.SharedUmemFD
761

762
	return unsafe.Pointer(&sa.raw), SizeofSockaddrXDP, nil
763
}
764

765
// This constant mirrors the #define of PX_PROTO_OE in
766
// linux/if_pppox.h. We're defining this by hand here instead of
767
// autogenerating through mkerrors.sh because including
768
// linux/if_pppox.h causes some declaration conflicts with other
769
// includes (linux/if_pppox.h includes linux/in.h, which conflicts
770
// with netinet/in.h). Given that we only need a single zero constant
771
// out of that file, it's cleaner to just define it by hand here.
772
const px_proto_oe = 0
773

774
type SockaddrPPPoE struct {
775
	SID    uint16
776
	Remote []byte
777
	Dev    string
778
	raw    RawSockaddrPPPoX
779
}
780

781
func (sa *SockaddrPPPoE) sockaddr() (unsafe.Pointer, _Socklen, error) {
782
	if len(sa.Remote) != 6 {
783
		return nil, 0, EINVAL
784
	}
785
	if len(sa.Dev) > IFNAMSIZ-1 {
786
		return nil, 0, EINVAL
787
	}
788

789
	*(*uint16)(unsafe.Pointer(&sa.raw[0])) = AF_PPPOX
790
	// This next field is in host-endian byte order. We can't use the
791
	// same unsafe pointer cast as above, because this value is not
792
	// 32-bit aligned and some architectures don't allow unaligned
793
	// access.
794
	//
795
	// However, the value of px_proto_oe is 0, so we can use
796
	// encoding/binary helpers to write the bytes without worrying
797
	// about the ordering.
798
	binary.BigEndian.PutUint32(sa.raw[2:6], px_proto_oe)
799
	// This field is deliberately big-endian, unlike the previous
800
	// one. The kernel expects SID to be in network byte order.
801
	binary.BigEndian.PutUint16(sa.raw[6:8], sa.SID)
802
	copy(sa.raw[8:14], sa.Remote)
803
	for i := 14; i < 14+IFNAMSIZ; i++ {
804
		sa.raw[i] = 0
805
	}
806
	copy(sa.raw[14:], sa.Dev)
807
	return unsafe.Pointer(&sa.raw), SizeofSockaddrPPPoX, nil
808
}
809

810
// SockaddrTIPC implements the Sockaddr interface for AF_TIPC type sockets.
811
// For more information on TIPC, see: http://tipc.sourceforge.net/.
812
type SockaddrTIPC struct {
813
	// Scope is the publication scopes when binding service/service range.
814
	// Should be set to TIPC_CLUSTER_SCOPE or TIPC_NODE_SCOPE.
815
	Scope int
816

817
	// Addr is the type of address used to manipulate a socket. Addr must be
818
	// one of:
819
	//  - *TIPCSocketAddr: "id" variant in the C addr union
820
	//  - *TIPCServiceRange: "nameseq" variant in the C addr union
821
	//  - *TIPCServiceName: "name" variant in the C addr union
822
	//
823
	// If nil, EINVAL will be returned when the structure is used.
824
	Addr TIPCAddr
825

826
	raw RawSockaddrTIPC
827
}
828

829
// TIPCAddr is implemented by types that can be used as an address for
830
// SockaddrTIPC. It is only implemented by *TIPCSocketAddr, *TIPCServiceRange,
831
// and *TIPCServiceName.
832
type TIPCAddr interface {
833
	tipcAddrtype() uint8
834
	tipcAddr() [12]byte
835
}
836

837
func (sa *TIPCSocketAddr) tipcAddr() [12]byte {
838
	var out [12]byte
839
	copy(out[:], (*(*[unsafe.Sizeof(TIPCSocketAddr{})]byte)(unsafe.Pointer(sa)))[:])
840
	return out
841
}
842

843
func (sa *TIPCSocketAddr) tipcAddrtype() uint8 { return TIPC_SOCKET_ADDR }
844

845
func (sa *TIPCServiceRange) tipcAddr() [12]byte {
846
	var out [12]byte
847
	copy(out[:], (*(*[unsafe.Sizeof(TIPCServiceRange{})]byte)(unsafe.Pointer(sa)))[:])
848
	return out
849
}
850

851
func (sa *TIPCServiceRange) tipcAddrtype() uint8 { return TIPC_SERVICE_RANGE }
852

853
func (sa *TIPCServiceName) tipcAddr() [12]byte {
854
	var out [12]byte
855
	copy(out[:], (*(*[unsafe.Sizeof(TIPCServiceName{})]byte)(unsafe.Pointer(sa)))[:])
856
	return out
857
}
858

859
func (sa *TIPCServiceName) tipcAddrtype() uint8 { return TIPC_SERVICE_ADDR }
860

861
func (sa *SockaddrTIPC) sockaddr() (unsafe.Pointer, _Socklen, error) {
862
	if sa.Addr == nil {
863
		return nil, 0, EINVAL
864
	}
865
	sa.raw.Family = AF_TIPC
866
	sa.raw.Scope = int8(sa.Scope)
867
	sa.raw.Addrtype = sa.Addr.tipcAddrtype()
868
	sa.raw.Addr = sa.Addr.tipcAddr()
869
	return unsafe.Pointer(&sa.raw), SizeofSockaddrTIPC, nil
870
}
871

872
// SockaddrL2TPIP implements the Sockaddr interface for IPPROTO_L2TP/AF_INET sockets.
873
type SockaddrL2TPIP struct {
874
	Addr   [4]byte
875
	ConnId uint32
876
	raw    RawSockaddrL2TPIP
877
}
878

879
func (sa *SockaddrL2TPIP) sockaddr() (unsafe.Pointer, _Socklen, error) {
880
	sa.raw.Family = AF_INET
881
	sa.raw.Conn_id = sa.ConnId
882
	sa.raw.Addr = sa.Addr
883
	return unsafe.Pointer(&sa.raw), SizeofSockaddrL2TPIP, nil
884
}
885

886
// SockaddrL2TPIP6 implements the Sockaddr interface for IPPROTO_L2TP/AF_INET6 sockets.
887
type SockaddrL2TPIP6 struct {
888
	Addr   [16]byte
889
	ZoneId uint32
890
	ConnId uint32
891
	raw    RawSockaddrL2TPIP6
892
}
893

894
func (sa *SockaddrL2TPIP6) sockaddr() (unsafe.Pointer, _Socklen, error) {
895
	sa.raw.Family = AF_INET6
896
	sa.raw.Conn_id = sa.ConnId
897
	sa.raw.Scope_id = sa.ZoneId
898
	sa.raw.Addr = sa.Addr
899
	return unsafe.Pointer(&sa.raw), SizeofSockaddrL2TPIP6, nil
900
}
901

902
// SockaddrIUCV implements the Sockaddr interface for AF_IUCV sockets.
903
type SockaddrIUCV struct {
904
	UserID string
905
	Name   string
906
	raw    RawSockaddrIUCV
907
}
908

909
func (sa *SockaddrIUCV) sockaddr() (unsafe.Pointer, _Socklen, error) {
910
	sa.raw.Family = AF_IUCV
911
	// These are EBCDIC encoded by the kernel, but we still need to pad them
912
	// with blanks. Initializing with blanks allows the caller to feed in either
913
	// a padded or an unpadded string.
914
	for i := 0; i < 8; i++ {
915
		sa.raw.Nodeid[i] = ' '
916
		sa.raw.User_id[i] = ' '
917
		sa.raw.Name[i] = ' '
918
	}
919
	if len(sa.UserID) > 8 || len(sa.Name) > 8 {
920
		return nil, 0, EINVAL
921
	}
922
	for i, b := range []byte(sa.UserID[:]) {
923
		sa.raw.User_id[i] = int8(b)
924
	}
925
	for i, b := range []byte(sa.Name[:]) {
926
		sa.raw.Name[i] = int8(b)
927
	}
928
	return unsafe.Pointer(&sa.raw), SizeofSockaddrIUCV, nil
929
}
930

931
type SockaddrNFC struct {
932
	DeviceIdx   uint32
933
	TargetIdx   uint32
934
	NFCProtocol uint32
935
	raw         RawSockaddrNFC
936
}
937

938
func (sa *SockaddrNFC) sockaddr() (unsafe.Pointer, _Socklen, error) {
939
	sa.raw.Sa_family = AF_NFC
940
	sa.raw.Dev_idx = sa.DeviceIdx
941
	sa.raw.Target_idx = sa.TargetIdx
942
	sa.raw.Nfc_protocol = sa.NFCProtocol
943
	return unsafe.Pointer(&sa.raw), SizeofSockaddrNFC, nil
944
}
945

946
type SockaddrNFCLLCP struct {
947
	DeviceIdx      uint32
948
	TargetIdx      uint32
949
	NFCProtocol    uint32
950
	DestinationSAP uint8
951
	SourceSAP      uint8
952
	ServiceName    string
953
	raw            RawSockaddrNFCLLCP
954
}
955

956
func (sa *SockaddrNFCLLCP) sockaddr() (unsafe.Pointer, _Socklen, error) {
957
	sa.raw.Sa_family = AF_NFC
958
	sa.raw.Dev_idx = sa.DeviceIdx
959
	sa.raw.Target_idx = sa.TargetIdx
960
	sa.raw.Nfc_protocol = sa.NFCProtocol
961
	sa.raw.Dsap = sa.DestinationSAP
962
	sa.raw.Ssap = sa.SourceSAP
963
	if len(sa.ServiceName) > len(sa.raw.Service_name) {
964
		return nil, 0, EINVAL
965
	}
966
	copy(sa.raw.Service_name[:], sa.ServiceName)
967
	sa.raw.SetServiceNameLen(len(sa.ServiceName))
968
	return unsafe.Pointer(&sa.raw), SizeofSockaddrNFCLLCP, nil
969
}
970

971
var socketProtocol = func(fd int) (int, error) {
972
	return GetsockoptInt(fd, SOL_SOCKET, SO_PROTOCOL)
973
}
974

975
func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) {
976
	switch rsa.Addr.Family {
977
	case AF_NETLINK:
978
		pp := (*RawSockaddrNetlink)(unsafe.Pointer(rsa))
979
		sa := new(SockaddrNetlink)
980
		sa.Family = pp.Family
981
		sa.Pad = pp.Pad
982
		sa.Pid = pp.Pid
983
		sa.Groups = pp.Groups
984
		return sa, nil
985

986
	case AF_PACKET:
987
		pp := (*RawSockaddrLinklayer)(unsafe.Pointer(rsa))
988
		sa := new(SockaddrLinklayer)
989
		sa.Protocol = pp.Protocol
990
		sa.Ifindex = int(pp.Ifindex)
991
		sa.Hatype = pp.Hatype
992
		sa.Pkttype = pp.Pkttype
993
		sa.Halen = pp.Halen
994
		sa.Addr = pp.Addr
995
		return sa, nil
996

997
	case AF_UNIX:
998
		pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa))
999
		sa := new(SockaddrUnix)
1000
		if pp.Path[0] == 0 {
1001
			// "Abstract" Unix domain socket.
1002
			// Rewrite leading NUL as @ for textual display.
1003
			// (This is the standard convention.)
1004
			// Not friendly to overwrite in place,
1005
			// but the callers below don't care.
1006
			pp.Path[0] = '@'
1007
		}
1008

1009
		// Assume path ends at NUL.
1010
		// This is not technically the Linux semantics for
1011
		// abstract Unix domain sockets--they are supposed
1012
		// to be uninterpreted fixed-size binary blobs--but
1013
		// everyone uses this convention.
1014
		n := 0
1015
		for n < len(pp.Path) && pp.Path[n] != 0 {
1016
			n++
1017
		}
1018
		sa.Name = string(unsafe.Slice((*byte)(unsafe.Pointer(&pp.Path[0])), n))
1019
		return sa, nil
1020

1021
	case AF_INET:
1022
		proto, err := socketProtocol(fd)
1023
		if err != nil {
1024
			return nil, err
1025
		}
1026

1027
		switch proto {
1028
		case IPPROTO_L2TP:
1029
			pp := (*RawSockaddrL2TPIP)(unsafe.Pointer(rsa))
1030
			sa := new(SockaddrL2TPIP)
1031
			sa.ConnId = pp.Conn_id
1032
			sa.Addr = pp.Addr
1033
			return sa, nil
1034
		default:
1035
			pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa))
1036
			sa := new(SockaddrInet4)
1037
			p := (*[2]byte)(unsafe.Pointer(&pp.Port))
1038
			sa.Port = int(p[0])<<8 + int(p[1])
1039
			sa.Addr = pp.Addr
1040
			return sa, nil
1041
		}
1042

1043
	case AF_INET6:
1044
		proto, err := socketProtocol(fd)
1045
		if err != nil {
1046
			return nil, err
1047
		}
1048

1049
		switch proto {
1050
		case IPPROTO_L2TP:
1051
			pp := (*RawSockaddrL2TPIP6)(unsafe.Pointer(rsa))
1052
			sa := new(SockaddrL2TPIP6)
1053
			sa.ConnId = pp.Conn_id
1054
			sa.ZoneId = pp.Scope_id
1055
			sa.Addr = pp.Addr
1056
			return sa, nil
1057
		default:
1058
			pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa))
1059
			sa := new(SockaddrInet6)
1060
			p := (*[2]byte)(unsafe.Pointer(&pp.Port))
1061
			sa.Port = int(p[0])<<8 + int(p[1])
1062
			sa.ZoneId = pp.Scope_id
1063
			sa.Addr = pp.Addr
1064
			return sa, nil
1065
		}
1066

1067
	case AF_VSOCK:
1068
		pp := (*RawSockaddrVM)(unsafe.Pointer(rsa))
1069
		sa := &SockaddrVM{
1070
			CID:   pp.Cid,
1071
			Port:  pp.Port,
1072
			Flags: pp.Flags,
1073
		}
1074
		return sa, nil
1075
	case AF_BLUETOOTH:
1076
		proto, err := socketProtocol(fd)
1077
		if err != nil {
1078
			return nil, err
1079
		}
1080
		// only BTPROTO_L2CAP and BTPROTO_RFCOMM can accept connections
1081
		switch proto {
1082
		case BTPROTO_L2CAP:
1083
			pp := (*RawSockaddrL2)(unsafe.Pointer(rsa))
1084
			sa := &SockaddrL2{
1085
				PSM:      pp.Psm,
1086
				CID:      pp.Cid,
1087
				Addr:     pp.Bdaddr,
1088
				AddrType: pp.Bdaddr_type,
1089
			}
1090
			return sa, nil
1091
		case BTPROTO_RFCOMM:
1092
			pp := (*RawSockaddrRFCOMM)(unsafe.Pointer(rsa))
1093
			sa := &SockaddrRFCOMM{
1094
				Channel: pp.Channel,
1095
				Addr:    pp.Bdaddr,
1096
			}
1097
			return sa, nil
1098
		}
1099
	case AF_XDP:
1100
		pp := (*RawSockaddrXDP)(unsafe.Pointer(rsa))
1101
		sa := &SockaddrXDP{
1102
			Flags:        pp.Flags,
1103
			Ifindex:      pp.Ifindex,
1104
			QueueID:      pp.Queue_id,
1105
			SharedUmemFD: pp.Shared_umem_fd,
1106
		}
1107
		return sa, nil
1108
	case AF_PPPOX:
1109
		pp := (*RawSockaddrPPPoX)(unsafe.Pointer(rsa))
1110
		if binary.BigEndian.Uint32(pp[2:6]) != px_proto_oe {
1111
			return nil, EINVAL
1112
		}
1113
		sa := &SockaddrPPPoE{
1114
			SID:    binary.BigEndian.Uint16(pp[6:8]),
1115
			Remote: pp[8:14],
1116
		}
1117
		for i := 14; i < 14+IFNAMSIZ; i++ {
1118
			if pp[i] == 0 {
1119
				sa.Dev = string(pp[14:i])
1120
				break
1121
			}
1122
		}
1123
		return sa, nil
1124
	case AF_TIPC:
1125
		pp := (*RawSockaddrTIPC)(unsafe.Pointer(rsa))
1126

1127
		sa := &SockaddrTIPC{
1128
			Scope: int(pp.Scope),
1129
		}
1130

1131
		// Determine which union variant is present in pp.Addr by checking
1132
		// pp.Addrtype.
1133
		switch pp.Addrtype {
1134
		case TIPC_SERVICE_RANGE:
1135
			sa.Addr = (*TIPCServiceRange)(unsafe.Pointer(&pp.Addr))
1136
		case TIPC_SERVICE_ADDR:
1137
			sa.Addr = (*TIPCServiceName)(unsafe.Pointer(&pp.Addr))
1138
		case TIPC_SOCKET_ADDR:
1139
			sa.Addr = (*TIPCSocketAddr)(unsafe.Pointer(&pp.Addr))
1140
		default:
1141
			return nil, EINVAL
1142
		}
1143

1144
		return sa, nil
1145
	case AF_IUCV:
1146
		pp := (*RawSockaddrIUCV)(unsafe.Pointer(rsa))
1147

1148
		var user [8]byte
1149
		var name [8]byte
1150

1151
		for i := 0; i < 8; i++ {
1152
			user[i] = byte(pp.User_id[i])
1153
			name[i] = byte(pp.Name[i])
1154
		}
1155

1156
		sa := &SockaddrIUCV{
1157
			UserID: string(user[:]),
1158
			Name:   string(name[:]),
1159
		}
1160
		return sa, nil
1161

1162
	case AF_CAN:
1163
		proto, err := socketProtocol(fd)
1164
		if err != nil {
1165
			return nil, err
1166
		}
1167

1168
		pp := (*RawSockaddrCAN)(unsafe.Pointer(rsa))
1169

1170
		switch proto {
1171
		case CAN_J1939:
1172
			sa := &SockaddrCANJ1939{
1173
				Ifindex: int(pp.Ifindex),
1174
			}
1175
			name := (*[8]byte)(unsafe.Pointer(&sa.Name))
1176
			for i := 0; i < 8; i++ {
1177
				name[i] = pp.Addr[i]
1178
			}
1179
			pgn := (*[4]byte)(unsafe.Pointer(&sa.PGN))
1180
			for i := 0; i < 4; i++ {
1181
				pgn[i] = pp.Addr[i+8]
1182
			}
1183
			addr := (*[1]byte)(unsafe.Pointer(&sa.Addr))
1184
			addr[0] = pp.Addr[12]
1185
			return sa, nil
1186
		default:
1187
			sa := &SockaddrCAN{
1188
				Ifindex: int(pp.Ifindex),
1189
			}
1190
			rx := (*[4]byte)(unsafe.Pointer(&sa.RxID))
1191
			for i := 0; i < 4; i++ {
1192
				rx[i] = pp.Addr[i]
1193
			}
1194
			tx := (*[4]byte)(unsafe.Pointer(&sa.TxID))
1195
			for i := 0; i < 4; i++ {
1196
				tx[i] = pp.Addr[i+4]
1197
			}
1198
			return sa, nil
1199
		}
1200
	case AF_NFC:
1201
		proto, err := socketProtocol(fd)
1202
		if err != nil {
1203
			return nil, err
1204
		}
1205
		switch proto {
1206
		case NFC_SOCKPROTO_RAW:
1207
			pp := (*RawSockaddrNFC)(unsafe.Pointer(rsa))
1208
			sa := &SockaddrNFC{
1209
				DeviceIdx:   pp.Dev_idx,
1210
				TargetIdx:   pp.Target_idx,
1211
				NFCProtocol: pp.Nfc_protocol,
1212
			}
1213
			return sa, nil
1214
		case NFC_SOCKPROTO_LLCP:
1215
			pp := (*RawSockaddrNFCLLCP)(unsafe.Pointer(rsa))
1216
			if uint64(pp.Service_name_len) > uint64(len(pp.Service_name)) {
1217
				return nil, EINVAL
1218
			}
1219
			sa := &SockaddrNFCLLCP{
1220
				DeviceIdx:      pp.Dev_idx,
1221
				TargetIdx:      pp.Target_idx,
1222
				NFCProtocol:    pp.Nfc_protocol,
1223
				DestinationSAP: pp.Dsap,
1224
				SourceSAP:      pp.Ssap,
1225
				ServiceName:    string(pp.Service_name[:pp.Service_name_len]),
1226
			}
1227
			return sa, nil
1228
		default:
1229
			return nil, EINVAL
1230
		}
1231
	}
1232
	return nil, EAFNOSUPPORT
1233
}
1234

1235
func Accept(fd int) (nfd int, sa Sockaddr, err error) {
1236
	var rsa RawSockaddrAny
1237
	var len _Socklen = SizeofSockaddrAny
1238
	nfd, err = accept4(fd, &rsa, &len, 0)
1239
	if err != nil {
1240
		return
1241
	}
1242
	sa, err = anyToSockaddr(fd, &rsa)
1243
	if err != nil {
1244
		Close(nfd)
1245
		nfd = 0
1246
	}
1247
	return
1248
}
1249

1250
func Accept4(fd int, flags int) (nfd int, sa Sockaddr, err error) {
1251
	var rsa RawSockaddrAny
1252
	var len _Socklen = SizeofSockaddrAny
1253
	nfd, err = accept4(fd, &rsa, &len, flags)
1254
	if err != nil {
1255
		return
1256
	}
1257
	if len > SizeofSockaddrAny {
1258
		panic("RawSockaddrAny too small")
1259
	}
1260
	sa, err = anyToSockaddr(fd, &rsa)
1261
	if err != nil {
1262
		Close(nfd)
1263
		nfd = 0
1264
	}
1265
	return
1266
}
1267

1268
func Getsockname(fd int) (sa Sockaddr, err error) {
1269
	var rsa RawSockaddrAny
1270
	var len _Socklen = SizeofSockaddrAny
1271
	if err = getsockname(fd, &rsa, &len); err != nil {
1272
		return
1273
	}
1274
	return anyToSockaddr(fd, &rsa)
1275
}
1276

1277
func GetsockoptIPMreqn(fd, level, opt int) (*IPMreqn, error) {
1278
	var value IPMreqn
1279
	vallen := _Socklen(SizeofIPMreqn)
1280
	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
1281
	return &value, err
1282
}
1283

1284
func GetsockoptUcred(fd, level, opt int) (*Ucred, error) {
1285
	var value Ucred
1286
	vallen := _Socklen(SizeofUcred)
1287
	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
1288
	return &value, err
1289
}
1290

1291
func GetsockoptTCPInfo(fd, level, opt int) (*TCPInfo, error) {
1292
	var value TCPInfo
1293
	vallen := _Socklen(SizeofTCPInfo)
1294
	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
1295
	return &value, err
1296
}
1297

1298
// GetsockoptString returns the string value of the socket option opt for the
1299
// socket associated with fd at the given socket level.
1300
func GetsockoptString(fd, level, opt int) (string, error) {
1301
	buf := make([]byte, 256)
1302
	vallen := _Socklen(len(buf))
1303
	err := getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen)
1304
	if err != nil {
1305
		if err == ERANGE {
1306
			buf = make([]byte, vallen)
1307
			err = getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen)
1308
		}
1309
		if err != nil {
1310
			return "", err
1311
		}
1312
	}
1313
	return string(buf[:vallen-1]), nil
1314
}
1315

1316
func GetsockoptTpacketStats(fd, level, opt int) (*TpacketStats, error) {
1317
	var value TpacketStats
1318
	vallen := _Socklen(SizeofTpacketStats)
1319
	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
1320
	return &value, err
1321
}
1322

1323
func GetsockoptTpacketStatsV3(fd, level, opt int) (*TpacketStatsV3, error) {
1324
	var value TpacketStatsV3
1325
	vallen := _Socklen(SizeofTpacketStatsV3)
1326
	err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen)
1327
	return &value, err
1328
}
1329

1330
func SetsockoptIPMreqn(fd, level, opt int, mreq *IPMreqn) (err error) {
1331
	return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq))
1332
}
1333

1334
func SetsockoptPacketMreq(fd, level, opt int, mreq *PacketMreq) error {
1335
	return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq))
1336
}
1337

1338
// SetsockoptSockFprog attaches a classic BPF or an extended BPF program to a
1339
// socket to filter incoming packets.  See 'man 7 socket' for usage information.
1340
func SetsockoptSockFprog(fd, level, opt int, fprog *SockFprog) error {
1341
	return setsockopt(fd, level, opt, unsafe.Pointer(fprog), unsafe.Sizeof(*fprog))
1342
}
1343

1344
func SetsockoptCanRawFilter(fd, level, opt int, filter []CanFilter) error {
1345
	var p unsafe.Pointer
1346
	if len(filter) > 0 {
1347
		p = unsafe.Pointer(&filter[0])
1348
	}
1349
	return setsockopt(fd, level, opt, p, uintptr(len(filter)*SizeofCanFilter))
1350
}
1351

1352
func SetsockoptTpacketReq(fd, level, opt int, tp *TpacketReq) error {
1353
	return setsockopt(fd, level, opt, unsafe.Pointer(tp), unsafe.Sizeof(*tp))
1354
}
1355

1356
func SetsockoptTpacketReq3(fd, level, opt int, tp *TpacketReq3) error {
1357
	return setsockopt(fd, level, opt, unsafe.Pointer(tp), unsafe.Sizeof(*tp))
1358
}
1359

1360
func SetsockoptTCPRepairOpt(fd, level, opt int, o []TCPRepairOpt) (err error) {
1361
	if len(o) == 0 {
1362
		return EINVAL
1363
	}
1364
	return setsockopt(fd, level, opt, unsafe.Pointer(&o[0]), uintptr(SizeofTCPRepairOpt*len(o)))
1365
}
1366

1367
func SetsockoptTCPMD5Sig(fd, level, opt int, s *TCPMD5Sig) error {
1368
	return setsockopt(fd, level, opt, unsafe.Pointer(s), unsafe.Sizeof(*s))
1369
}
1370

1371
// Keyctl Commands (http://man7.org/linux/man-pages/man2/keyctl.2.html)
1372

1373
// KeyctlInt calls keyctl commands in which each argument is an int.
1374
// These commands are KEYCTL_REVOKE, KEYCTL_CHOWN, KEYCTL_CLEAR, KEYCTL_LINK,
1375
// KEYCTL_UNLINK, KEYCTL_NEGATE, KEYCTL_SET_REQKEY_KEYRING, KEYCTL_SET_TIMEOUT,
1376
// KEYCTL_ASSUME_AUTHORITY, KEYCTL_SESSION_TO_PARENT, KEYCTL_REJECT,
1377
// KEYCTL_INVALIDATE, and KEYCTL_GET_PERSISTENT.
1378
//sys	KeyctlInt(cmd int, arg2 int, arg3 int, arg4 int, arg5 int) (ret int, err error) = SYS_KEYCTL
1379

1380
// KeyctlBuffer calls keyctl commands in which the third and fourth
1381
// arguments are a buffer and its length, respectively.
1382
// These commands are KEYCTL_UPDATE, KEYCTL_READ, and KEYCTL_INSTANTIATE.
1383
//sys	KeyctlBuffer(cmd int, arg2 int, buf []byte, arg5 int) (ret int, err error) = SYS_KEYCTL
1384

1385
// KeyctlString calls keyctl commands which return a string.
1386
// These commands are KEYCTL_DESCRIBE and KEYCTL_GET_SECURITY.
1387
func KeyctlString(cmd int, id int) (string, error) {
1388
	// We must loop as the string data may change in between the syscalls.
1389
	// We could allocate a large buffer here to reduce the chance that the
1390
	// syscall needs to be called twice; however, this is unnecessary as
1391
	// the performance loss is negligible.
1392
	var buffer []byte
1393
	for {
1394
		// Try to fill the buffer with data
1395
		length, err := KeyctlBuffer(cmd, id, buffer, 0)
1396
		if err != nil {
1397
			return "", err
1398
		}
1399

1400
		// Check if the data was written
1401
		if length <= len(buffer) {
1402
			// Exclude the null terminator
1403
			return string(buffer[:length-1]), nil
1404
		}
1405

1406
		// Make a bigger buffer if needed
1407
		buffer = make([]byte, length)
1408
	}
1409
}
1410

1411
// Keyctl commands with special signatures.
1412

1413
// KeyctlGetKeyringID implements the KEYCTL_GET_KEYRING_ID command.
1414
// See the full documentation at:
1415
// http://man7.org/linux/man-pages/man3/keyctl_get_keyring_ID.3.html
1416
func KeyctlGetKeyringID(id int, create bool) (ringid int, err error) {
1417
	createInt := 0
1418
	if create {
1419
		createInt = 1
1420
	}
1421
	return KeyctlInt(KEYCTL_GET_KEYRING_ID, id, createInt, 0, 0)
1422
}
1423

1424
// KeyctlSetperm implements the KEYCTL_SETPERM command. The perm value is the
1425
// key handle permission mask as described in the "keyctl setperm" section of
1426
// http://man7.org/linux/man-pages/man1/keyctl.1.html.
1427
// See the full documentation at:
1428
// http://man7.org/linux/man-pages/man3/keyctl_setperm.3.html
1429
func KeyctlSetperm(id int, perm uint32) error {
1430
	_, err := KeyctlInt(KEYCTL_SETPERM, id, int(perm), 0, 0)
1431
	return err
1432
}
1433

1434
//sys	keyctlJoin(cmd int, arg2 string) (ret int, err error) = SYS_KEYCTL
1435

1436
// KeyctlJoinSessionKeyring implements the KEYCTL_JOIN_SESSION_KEYRING command.
1437
// See the full documentation at:
1438
// http://man7.org/linux/man-pages/man3/keyctl_join_session_keyring.3.html
1439
func KeyctlJoinSessionKeyring(name string) (ringid int, err error) {
1440
	return keyctlJoin(KEYCTL_JOIN_SESSION_KEYRING, name)
1441
}
1442

1443
//sys	keyctlSearch(cmd int, arg2 int, arg3 string, arg4 string, arg5 int) (ret int, err error) = SYS_KEYCTL
1444

1445
// KeyctlSearch implements the KEYCTL_SEARCH command.
1446
// See the full documentation at:
1447
// http://man7.org/linux/man-pages/man3/keyctl_search.3.html
1448
func KeyctlSearch(ringid int, keyType, description string, destRingid int) (id int, err error) {
1449
	return keyctlSearch(KEYCTL_SEARCH, ringid, keyType, description, destRingid)
1450
}
1451

1452
//sys	keyctlIOV(cmd int, arg2 int, payload []Iovec, arg5 int) (err error) = SYS_KEYCTL
1453

1454
// KeyctlInstantiateIOV implements the KEYCTL_INSTANTIATE_IOV command. This
1455
// command is similar to KEYCTL_INSTANTIATE, except that the payload is a slice
1456
// of Iovec (each of which represents a buffer) instead of a single buffer.
1457
// See the full documentation at:
1458
// http://man7.org/linux/man-pages/man3/keyctl_instantiate_iov.3.html
1459
func KeyctlInstantiateIOV(id int, payload []Iovec, ringid int) error {
1460
	return keyctlIOV(KEYCTL_INSTANTIATE_IOV, id, payload, ringid)
1461
}
1462

1463
//sys	keyctlDH(cmd int, arg2 *KeyctlDHParams, buf []byte) (ret int, err error) = SYS_KEYCTL
1464

1465
// KeyctlDHCompute implements the KEYCTL_DH_COMPUTE command. This command
1466
// computes a Diffie-Hellman shared secret based on the provide params. The
1467
// secret is written to the provided buffer and the returned size is the number
1468
// of bytes written (returning an error if there is insufficient space in the
1469
// buffer). If a nil buffer is passed in, this function returns the minimum
1470
// buffer length needed to store the appropriate data. Note that this differs
1471
// from KEYCTL_READ's behavior which always returns the requested payload size.
1472
// See the full documentation at:
1473
// http://man7.org/linux/man-pages/man3/keyctl_dh_compute.3.html
1474
func KeyctlDHCompute(params *KeyctlDHParams, buffer []byte) (size int, err error) {
1475
	return keyctlDH(KEYCTL_DH_COMPUTE, params, buffer)
1476
}
1477

1478
// KeyctlRestrictKeyring implements the KEYCTL_RESTRICT_KEYRING command. This
1479
// command limits the set of keys that can be linked to the keyring, regardless
1480
// of keyring permissions. The command requires the "setattr" permission.
1481
//
1482
// When called with an empty keyType the command locks the keyring, preventing
1483
// any further keys from being linked to the keyring.
1484
//
1485
// The "asymmetric" keyType defines restrictions requiring key payloads to be
1486
// DER encoded X.509 certificates signed by keys in another keyring. Restrictions
1487
// for "asymmetric" include "builtin_trusted", "builtin_and_secondary_trusted",
1488
// "key_or_keyring:<key>", and "key_or_keyring:<key>:chain".
1489
//
1490
// As of Linux 4.12, only the "asymmetric" keyType defines type-specific
1491
// restrictions.
1492
//
1493
// See the full documentation at:
1494
// http://man7.org/linux/man-pages/man3/keyctl_restrict_keyring.3.html
1495
// http://man7.org/linux/man-pages/man2/keyctl.2.html
1496
func KeyctlRestrictKeyring(ringid int, keyType string, restriction string) error {
1497
	if keyType == "" {
1498
		return keyctlRestrictKeyring(KEYCTL_RESTRICT_KEYRING, ringid)
1499
	}
1500
	return keyctlRestrictKeyringByType(KEYCTL_RESTRICT_KEYRING, ringid, keyType, restriction)
1501
}
1502

1503
//sys	keyctlRestrictKeyringByType(cmd int, arg2 int, keyType string, restriction string) (err error) = SYS_KEYCTL
1504
//sys	keyctlRestrictKeyring(cmd int, arg2 int) (err error) = SYS_KEYCTL
1505

1506
func recvmsgRaw(fd int, iov []Iovec, oob []byte, flags int, rsa *RawSockaddrAny) (n, oobn int, recvflags int, err error) {
1507
	var msg Msghdr
1508
	msg.Name = (*byte)(unsafe.Pointer(rsa))
1509
	msg.Namelen = uint32(SizeofSockaddrAny)
1510
	var dummy byte
1511
	if len(oob) > 0 {
1512
		if emptyIovecs(iov) {
1513
			var sockType int
1514
			sockType, err = GetsockoptInt(fd, SOL_SOCKET, SO_TYPE)
1515
			if err != nil {
1516
				return
1517
			}
1518
			// receive at least one normal byte
1519
			if sockType != SOCK_DGRAM {
1520
				var iova [1]Iovec
1521
				iova[0].Base = &dummy
1522
				iova[0].SetLen(1)
1523
				iov = iova[:]
1524
			}
1525
		}
1526
		msg.Control = &oob[0]
1527
		msg.SetControllen(len(oob))
1528
	}
1529
	if len(iov) > 0 {
1530
		msg.Iov = &iov[0]
1531
		msg.SetIovlen(len(iov))
1532
	}
1533
	if n, err = recvmsg(fd, &msg, flags); err != nil {
1534
		return
1535
	}
1536
	oobn = int(msg.Controllen)
1537
	recvflags = int(msg.Flags)
1538
	return
1539
}
1540

1541
func sendmsgN(fd int, iov []Iovec, oob []byte, ptr unsafe.Pointer, salen _Socklen, flags int) (n int, err error) {
1542
	var msg Msghdr
1543
	msg.Name = (*byte)(ptr)
1544
	msg.Namelen = uint32(salen)
1545
	var dummy byte
1546
	var empty bool
1547
	if len(oob) > 0 {
1548
		empty = emptyIovecs(iov)
1549
		if empty {
1550
			var sockType int
1551
			sockType, err = GetsockoptInt(fd, SOL_SOCKET, SO_TYPE)
1552
			if err != nil {
1553
				return 0, err
1554
			}
1555
			// send at least one normal byte
1556
			if sockType != SOCK_DGRAM {
1557
				var iova [1]Iovec
1558
				iova[0].Base = &dummy
1559
				iova[0].SetLen(1)
1560
				iov = iova[:]
1561
			}
1562
		}
1563
		msg.Control = &oob[0]
1564
		msg.SetControllen(len(oob))
1565
	}
1566
	if len(iov) > 0 {
1567
		msg.Iov = &iov[0]
1568
		msg.SetIovlen(len(iov))
1569
	}
1570
	if n, err = sendmsg(fd, &msg, flags); err != nil {
1571
		return 0, err
1572
	}
1573
	if len(oob) > 0 && empty {
1574
		n = 0
1575
	}
1576
	return n, nil
1577
}
1578

1579
// BindToDevice binds the socket associated with fd to device.
1580
func BindToDevice(fd int, device string) (err error) {
1581
	return SetsockoptString(fd, SOL_SOCKET, SO_BINDTODEVICE, device)
1582
}
1583

1584
//sys	ptrace(request int, pid int, addr uintptr, data uintptr) (err error)
1585
//sys	ptracePtr(request int, pid int, addr uintptr, data unsafe.Pointer) (err error) = SYS_PTRACE
1586

1587
func ptracePeek(req int, pid int, addr uintptr, out []byte) (count int, err error) {
1588
	// The peek requests are machine-size oriented, so we wrap it
1589
	// to retrieve arbitrary-length data.
1590

1591
	// The ptrace syscall differs from glibc's ptrace.
1592
	// Peeks returns the word in *data, not as the return value.
1593

1594
	var buf [SizeofPtr]byte
1595

1596
	// Leading edge. PEEKTEXT/PEEKDATA don't require aligned
1597
	// access (PEEKUSER warns that it might), but if we don't
1598
	// align our reads, we might straddle an unmapped page
1599
	// boundary and not get the bytes leading up to the page
1600
	// boundary.
1601
	n := 0
1602
	if addr%SizeofPtr != 0 {
1603
		err = ptracePtr(req, pid, addr-addr%SizeofPtr, unsafe.Pointer(&buf[0]))
1604
		if err != nil {
1605
			return 0, err
1606
		}
1607
		n += copy(out, buf[addr%SizeofPtr:])
1608
		out = out[n:]
1609
	}
1610

1611
	// Remainder.
1612
	for len(out) > 0 {
1613
		// We use an internal buffer to guarantee alignment.
1614
		// It's not documented if this is necessary, but we're paranoid.
1615
		err = ptracePtr(req, pid, addr+uintptr(n), unsafe.Pointer(&buf[0]))
1616
		if err != nil {
1617
			return n, err
1618
		}
1619
		copied := copy(out, buf[0:])
1620
		n += copied
1621
		out = out[copied:]
1622
	}
1623

1624
	return n, nil
1625
}
1626

1627
func PtracePeekText(pid int, addr uintptr, out []byte) (count int, err error) {
1628
	return ptracePeek(PTRACE_PEEKTEXT, pid, addr, out)
1629
}
1630

1631
func PtracePeekData(pid int, addr uintptr, out []byte) (count int, err error) {
1632
	return ptracePeek(PTRACE_PEEKDATA, pid, addr, out)
1633
}
1634

1635
func PtracePeekUser(pid int, addr uintptr, out []byte) (count int, err error) {
1636
	return ptracePeek(PTRACE_PEEKUSR, pid, addr, out)
1637
}
1638

1639
func ptracePoke(pokeReq int, peekReq int, pid int, addr uintptr, data []byte) (count int, err error) {
1640
	// As for ptracePeek, we need to align our accesses to deal
1641
	// with the possibility of straddling an invalid page.
1642

1643
	// Leading edge.
1644
	n := 0
1645
	if addr%SizeofPtr != 0 {
1646
		var buf [SizeofPtr]byte
1647
		err = ptracePtr(peekReq, pid, addr-addr%SizeofPtr, unsafe.Pointer(&buf[0]))
1648
		if err != nil {
1649
			return 0, err
1650
		}
1651
		n += copy(buf[addr%SizeofPtr:], data)
1652
		word := *((*uintptr)(unsafe.Pointer(&buf[0])))
1653
		err = ptrace(pokeReq, pid, addr-addr%SizeofPtr, word)
1654
		if err != nil {
1655
			return 0, err
1656
		}
1657
		data = data[n:]
1658
	}
1659

1660
	// Interior.
1661
	for len(data) > SizeofPtr {
1662
		word := *((*uintptr)(unsafe.Pointer(&data[0])))
1663
		err = ptrace(pokeReq, pid, addr+uintptr(n), word)
1664
		if err != nil {
1665
			return n, err
1666
		}
1667
		n += SizeofPtr
1668
		data = data[SizeofPtr:]
1669
	}
1670

1671
	// Trailing edge.
1672
	if len(data) > 0 {
1673
		var buf [SizeofPtr]byte
1674
		err = ptracePtr(peekReq, pid, addr+uintptr(n), unsafe.Pointer(&buf[0]))
1675
		if err != nil {
1676
			return n, err
1677
		}
1678
		copy(buf[0:], data)
1679
		word := *((*uintptr)(unsafe.Pointer(&buf[0])))
1680
		err = ptrace(pokeReq, pid, addr+uintptr(n), word)
1681
		if err != nil {
1682
			return n, err
1683
		}
1684
		n += len(data)
1685
	}
1686

1687
	return n, nil
1688
}
1689

1690
func PtracePokeText(pid int, addr uintptr, data []byte) (count int, err error) {
1691
	return ptracePoke(PTRACE_POKETEXT, PTRACE_PEEKTEXT, pid, addr, data)
1692
}
1693

1694
func PtracePokeData(pid int, addr uintptr, data []byte) (count int, err error) {
1695
	return ptracePoke(PTRACE_POKEDATA, PTRACE_PEEKDATA, pid, addr, data)
1696
}
1697

1698
func PtracePokeUser(pid int, addr uintptr, data []byte) (count int, err error) {
1699
	return ptracePoke(PTRACE_POKEUSR, PTRACE_PEEKUSR, pid, addr, data)
1700
}
1701

1702
func PtraceGetRegs(pid int, regsout *PtraceRegs) (err error) {
1703
	return ptracePtr(PTRACE_GETREGS, pid, 0, unsafe.Pointer(regsout))
1704
}
1705

1706
func PtraceSetRegs(pid int, regs *PtraceRegs) (err error) {
1707
	return ptracePtr(PTRACE_SETREGS, pid, 0, unsafe.Pointer(regs))
1708
}
1709

1710
func PtraceSetOptions(pid int, options int) (err error) {
1711
	return ptrace(PTRACE_SETOPTIONS, pid, 0, uintptr(options))
1712
}
1713

1714
func PtraceGetEventMsg(pid int) (msg uint, err error) {
1715
	var data _C_long
1716
	err = ptracePtr(PTRACE_GETEVENTMSG, pid, 0, unsafe.Pointer(&data))
1717
	msg = uint(data)
1718
	return
1719
}
1720

1721
func PtraceCont(pid int, signal int) (err error) {
1722
	return ptrace(PTRACE_CONT, pid, 0, uintptr(signal))
1723
}
1724

1725
func PtraceSyscall(pid int, signal int) (err error) {
1726
	return ptrace(PTRACE_SYSCALL, pid, 0, uintptr(signal))
1727
}
1728

1729
func PtraceSingleStep(pid int) (err error) { return ptrace(PTRACE_SINGLESTEP, pid, 0, 0) }
1730

1731
func PtraceInterrupt(pid int) (err error) { return ptrace(PTRACE_INTERRUPT, pid, 0, 0) }
1732

1733
func PtraceAttach(pid int) (err error) { return ptrace(PTRACE_ATTACH, pid, 0, 0) }
1734

1735
func PtraceSeize(pid int) (err error) { return ptrace(PTRACE_SEIZE, pid, 0, 0) }
1736

1737
func PtraceDetach(pid int) (err error) { return ptrace(PTRACE_DETACH, pid, 0, 0) }
1738

1739
//sys	reboot(magic1 uint, magic2 uint, cmd int, arg string) (err error)
1740

1741
func Reboot(cmd int) (err error) {
1742
	return reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, cmd, "")
1743
}
1744

1745
func direntIno(buf []byte) (uint64, bool) {
1746
	return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino))
1747
}
1748

1749
func direntReclen(buf []byte) (uint64, bool) {
1750
	return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen))
1751
}
1752

1753
func direntNamlen(buf []byte) (uint64, bool) {
1754
	reclen, ok := direntReclen(buf)
1755
	if !ok {
1756
		return 0, false
1757
	}
1758
	return reclen - uint64(unsafe.Offsetof(Dirent{}.Name)), true
1759
}
1760

1761
//sys	mount(source string, target string, fstype string, flags uintptr, data *byte) (err error)
1762

1763
func Mount(source string, target string, fstype string, flags uintptr, data string) (err error) {
1764
	// Certain file systems get rather angry and EINVAL if you give
1765
	// them an empty string of data, rather than NULL.
1766
	if data == "" {
1767
		return mount(source, target, fstype, flags, nil)
1768
	}
1769
	datap, err := BytePtrFromString(data)
1770
	if err != nil {
1771
		return err
1772
	}
1773
	return mount(source, target, fstype, flags, datap)
1774
}
1775

1776
//sys	mountSetattr(dirfd int, pathname string, flags uint, attr *MountAttr, size uintptr) (err error) = SYS_MOUNT_SETATTR
1777

1778
// MountSetattr is a wrapper for mount_setattr(2).
1779
// https://man7.org/linux/man-pages/man2/mount_setattr.2.html
1780
//
1781
// Requires kernel >= 5.12.
1782
func MountSetattr(dirfd int, pathname string, flags uint, attr *MountAttr) error {
1783
	return mountSetattr(dirfd, pathname, flags, attr, unsafe.Sizeof(*attr))
1784
}
1785

1786
func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
1787
	if raceenabled {
1788
		raceReleaseMerge(unsafe.Pointer(&ioSync))
1789
	}
1790
	return sendfile(outfd, infd, offset, count)
1791
}
1792

1793
// Sendto
1794
// Recvfrom
1795
// Socketpair
1796

1797
/*
1798
 * Direct access
1799
 */
1800
//sys	Acct(path string) (err error)
1801
//sys	AddKey(keyType string, description string, payload []byte, ringid int) (id int, err error)
1802
//sys	Adjtimex(buf *Timex) (state int, err error)
1803
//sysnb	Capget(hdr *CapUserHeader, data *CapUserData) (err error)
1804
//sysnb	Capset(hdr *CapUserHeader, data *CapUserData) (err error)
1805
//sys	Chdir(path string) (err error)
1806
//sys	Chroot(path string) (err error)
1807
//sys	ClockAdjtime(clockid int32, buf *Timex) (state int, err error)
1808
//sys	ClockGetres(clockid int32, res *Timespec) (err error)
1809
//sys	ClockGettime(clockid int32, time *Timespec) (err error)
1810
//sys	ClockNanosleep(clockid int32, flags int, request *Timespec, remain *Timespec) (err error)
1811
//sys	Close(fd int) (err error)
1812
//sys	CloseRange(first uint, last uint, flags uint) (err error)
1813
//sys	CopyFileRange(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int, err error)
1814
//sys	DeleteModule(name string, flags int) (err error)
1815
//sys	Dup(oldfd int) (fd int, err error)
1816

1817
func Dup2(oldfd, newfd int) error {
1818
	return Dup3(oldfd, newfd, 0)
1819
}
1820

1821
//sys	Dup3(oldfd int, newfd int, flags int) (err error)
1822
//sysnb	EpollCreate1(flag int) (fd int, err error)
1823
//sysnb	EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error)
1824
//sys	Eventfd(initval uint, flags int) (fd int, err error) = SYS_EVENTFD2
1825
//sys	Exit(code int) = SYS_EXIT_GROUP
1826
//sys	Fallocate(fd int, mode uint32, off int64, len int64) (err error)
1827
//sys	Fchdir(fd int) (err error)
1828
//sys	Fchmod(fd int, mode uint32) (err error)
1829
//sys	Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error)
1830
//sys	Fdatasync(fd int) (err error)
1831
//sys	Fgetxattr(fd int, attr string, dest []byte) (sz int, err error)
1832
//sys	FinitModule(fd int, params string, flags int) (err error)
1833
//sys	Flistxattr(fd int, dest []byte) (sz int, err error)
1834
//sys	Flock(fd int, how int) (err error)
1835
//sys	Fremovexattr(fd int, attr string) (err error)
1836
//sys	Fsetxattr(fd int, attr string, dest []byte, flags int) (err error)
1837
//sys	Fsync(fd int) (err error)
1838
//sys	Fsmount(fd int, flags int, mountAttrs int) (fsfd int, err error)
1839
//sys	Fsopen(fsName string, flags int) (fd int, err error)
1840
//sys	Fspick(dirfd int, pathName string, flags int) (fd int, err error)
1841
//sys	Getdents(fd int, buf []byte) (n int, err error) = SYS_GETDENTS64
1842
//sysnb	Getpgid(pid int) (pgid int, err error)
1843

1844
func Getpgrp() (pid int) {
1845
	pid, _ = Getpgid(0)
1846
	return
1847
}
1848

1849
//sysnb	Getpid() (pid int)
1850
//sysnb	Getppid() (ppid int)
1851
//sys	Getpriority(which int, who int) (prio int, err error)
1852
//sys	Getrandom(buf []byte, flags int) (n int, err error)
1853
//sysnb	Getrusage(who int, rusage *Rusage) (err error)
1854
//sysnb	Getsid(pid int) (sid int, err error)
1855
//sysnb	Gettid() (tid int)
1856
//sys	Getxattr(path string, attr string, dest []byte) (sz int, err error)
1857
//sys	InitModule(moduleImage []byte, params string) (err error)
1858
//sys	InotifyAddWatch(fd int, pathname string, mask uint32) (watchdesc int, err error)
1859
//sysnb	InotifyInit1(flags int) (fd int, err error)
1860
//sysnb	InotifyRmWatch(fd int, watchdesc uint32) (success int, err error)
1861
//sysnb	Kill(pid int, sig syscall.Signal) (err error)
1862
//sys	Klogctl(typ int, buf []byte) (n int, err error) = SYS_SYSLOG
1863
//sys	Lgetxattr(path string, attr string, dest []byte) (sz int, err error)
1864
//sys	Listxattr(path string, dest []byte) (sz int, err error)
1865
//sys	Llistxattr(path string, dest []byte) (sz int, err error)
1866
//sys	Lremovexattr(path string, attr string) (err error)
1867
//sys	Lsetxattr(path string, attr string, data []byte, flags int) (err error)
1868
//sys	MemfdCreate(name string, flags int) (fd int, err error)
1869
//sys	Mkdirat(dirfd int, path string, mode uint32) (err error)
1870
//sys	Mknodat(dirfd int, path string, mode uint32, dev int) (err error)
1871
//sys	MoveMount(fromDirfd int, fromPathName string, toDirfd int, toPathName string, flags int) (err error)
1872
//sys	Nanosleep(time *Timespec, leftover *Timespec) (err error)
1873
//sys	OpenTree(dfd int, fileName string, flags uint) (r int, err error)
1874
//sys	PerfEventOpen(attr *PerfEventAttr, pid int, cpu int, groupFd int, flags int) (fd int, err error)
1875
//sys	PivotRoot(newroot string, putold string) (err error) = SYS_PIVOT_ROOT
1876
//sys	Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error)
1877
//sys	Pselect(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timespec, sigmask *Sigset_t) (n int, err error) = SYS_PSELECT6
1878
//sys	read(fd int, p []byte) (n int, err error)
1879
//sys	Removexattr(path string, attr string) (err error)
1880
//sys	Renameat2(olddirfd int, oldpath string, newdirfd int, newpath string, flags uint) (err error)
1881
//sys	RequestKey(keyType string, description string, callback string, destRingid int) (id int, err error)
1882
//sys	Setdomainname(p []byte) (err error)
1883
//sys	Sethostname(p []byte) (err error)
1884
//sysnb	Setpgid(pid int, pgid int) (err error)
1885
//sysnb	Setsid() (pid int, err error)
1886
//sysnb	Settimeofday(tv *Timeval) (err error)
1887
//sys	Setns(fd int, nstype int) (err error)
1888

1889
//go:linkname syscall_prlimit syscall.prlimit
1890
func syscall_prlimit(pid, resource int, newlimit, old *syscall.Rlimit) error
1891

1892
func Prlimit(pid, resource int, newlimit, old *Rlimit) error {
1893
	// Just call the syscall version, because as of Go 1.21
1894
	// it will affect starting a new process.
1895
	return syscall_prlimit(pid, resource, (*syscall.Rlimit)(newlimit), (*syscall.Rlimit)(old))
1896
}
1897

1898
// PrctlRetInt performs a prctl operation specified by option and further
1899
// optional arguments arg2 through arg5 depending on option. It returns a
1900
// non-negative integer that is returned by the prctl syscall.
1901
func PrctlRetInt(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (int, error) {
1902
	ret, _, err := Syscall6(SYS_PRCTL, uintptr(option), uintptr(arg2), uintptr(arg3), uintptr(arg4), uintptr(arg5), 0)
1903
	if err != 0 {
1904
		return 0, err
1905
	}
1906
	return int(ret), nil
1907
}
1908

1909
func Setuid(uid int) (err error) {
1910
	return syscall.Setuid(uid)
1911
}
1912

1913
func Setgid(gid int) (err error) {
1914
	return syscall.Setgid(gid)
1915
}
1916

1917
func Setreuid(ruid, euid int) (err error) {
1918
	return syscall.Setreuid(ruid, euid)
1919
}
1920

1921
func Setregid(rgid, egid int) (err error) {
1922
	return syscall.Setregid(rgid, egid)
1923
}
1924

1925
func Setresuid(ruid, euid, suid int) (err error) {
1926
	return syscall.Setresuid(ruid, euid, suid)
1927
}
1928

1929
func Setresgid(rgid, egid, sgid int) (err error) {
1930
	return syscall.Setresgid(rgid, egid, sgid)
1931
}
1932

1933
// SetfsgidRetGid sets fsgid for current thread and returns previous fsgid set.
1934
// setfsgid(2) will return a non-nil error only if its caller lacks CAP_SETUID capability.
1935
// If the call fails due to other reasons, current fsgid will be returned.
1936
func SetfsgidRetGid(gid int) (int, error) {
1937
	return setfsgid(gid)
1938
}
1939

1940
// SetfsuidRetUid sets fsuid for current thread and returns previous fsuid set.
1941
// setfsgid(2) will return a non-nil error only if its caller lacks CAP_SETUID capability
1942
// If the call fails due to other reasons, current fsuid will be returned.
1943
func SetfsuidRetUid(uid int) (int, error) {
1944
	return setfsuid(uid)
1945
}
1946

1947
func Setfsgid(gid int) error {
1948
	_, err := setfsgid(gid)
1949
	return err
1950
}
1951

1952
func Setfsuid(uid int) error {
1953
	_, err := setfsuid(uid)
1954
	return err
1955
}
1956

1957
func Signalfd(fd int, sigmask *Sigset_t, flags int) (newfd int, err error) {
1958
	return signalfd(fd, sigmask, _C__NSIG/8, flags)
1959
}
1960

1961
//sys	Setpriority(which int, who int, prio int) (err error)
1962
//sys	Setxattr(path string, attr string, data []byte, flags int) (err error)
1963
//sys	signalfd(fd int, sigmask *Sigset_t, maskSize uintptr, flags int) (newfd int, err error) = SYS_SIGNALFD4
1964
//sys	Statx(dirfd int, path string, flags int, mask int, stat *Statx_t) (err error)
1965
//sys	Sync()
1966
//sys	Syncfs(fd int) (err error)
1967
//sysnb	Sysinfo(info *Sysinfo_t) (err error)
1968
//sys	Tee(rfd int, wfd int, len int, flags int) (n int64, err error)
1969
//sysnb	TimerfdCreate(clockid int, flags int) (fd int, err error)
1970
//sysnb	TimerfdGettime(fd int, currValue *ItimerSpec) (err error)
1971
//sysnb	TimerfdSettime(fd int, flags int, newValue *ItimerSpec, oldValue *ItimerSpec) (err error)
1972
//sysnb	Tgkill(tgid int, tid int, sig syscall.Signal) (err error)
1973
//sysnb	Times(tms *Tms) (ticks uintptr, err error)
1974
//sysnb	Umask(mask int) (oldmask int)
1975
//sysnb	Uname(buf *Utsname) (err error)
1976
//sys	Unmount(target string, flags int) (err error) = SYS_UMOUNT2
1977
//sys	Unshare(flags int) (err error)
1978
//sys	write(fd int, p []byte) (n int, err error)
1979
//sys	exitThread(code int) (err error) = SYS_EXIT
1980
//sys	readlen(fd int, p *byte, np int) (n int, err error) = SYS_READ
1981
//sys	writelen(fd int, p *byte, np int) (n int, err error) = SYS_WRITE
1982
//sys	readv(fd int, iovs []Iovec) (n int, err error) = SYS_READV
1983
//sys	writev(fd int, iovs []Iovec) (n int, err error) = SYS_WRITEV
1984
//sys	preadv(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err error) = SYS_PREADV
1985
//sys	pwritev(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err error) = SYS_PWRITEV
1986
//sys	preadv2(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr, flags int) (n int, err error) = SYS_PREADV2
1987
//sys	pwritev2(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr, flags int) (n int, err error) = SYS_PWRITEV2
1988

1989
// minIovec is the size of the small initial allocation used by
1990
// Readv, Writev, etc.
1991
//
1992
// This small allocation gets stack allocated, which lets the
1993
// common use case of len(iovs) <= minIovs avoid more expensive
1994
// heap allocations.
1995
const minIovec = 8
1996

1997
// appendBytes converts bs to Iovecs and appends them to vecs.
1998
func appendBytes(vecs []Iovec, bs [][]byte) []Iovec {
1999
	for _, b := range bs {
2000
		var v Iovec
2001
		v.SetLen(len(b))
2002
		if len(b) > 0 {
2003
			v.Base = &b[0]
2004
		} else {
2005
			v.Base = (*byte)(unsafe.Pointer(&_zero))
2006
		}
2007
		vecs = append(vecs, v)
2008
	}
2009
	return vecs
2010
}
2011

2012
// offs2lohi splits offs into its low and high order bits.
2013
func offs2lohi(offs int64) (lo, hi uintptr) {
2014
	const longBits = SizeofLong * 8
2015
	return uintptr(offs), uintptr(uint64(offs) >> (longBits - 1) >> 1) // two shifts to avoid false positive in vet
2016
}
2017

2018
func Readv(fd int, iovs [][]byte) (n int, err error) {
2019
	iovecs := make([]Iovec, 0, minIovec)
2020
	iovecs = appendBytes(iovecs, iovs)
2021
	n, err = readv(fd, iovecs)
2022
	readvRacedetect(iovecs, n, err)
2023
	return n, err
2024
}
2025

2026
func Preadv(fd int, iovs [][]byte, offset int64) (n int, err error) {
2027
	iovecs := make([]Iovec, 0, minIovec)
2028
	iovecs = appendBytes(iovecs, iovs)
2029
	lo, hi := offs2lohi(offset)
2030
	n, err = preadv(fd, iovecs, lo, hi)
2031
	readvRacedetect(iovecs, n, err)
2032
	return n, err
2033
}
2034

2035
func Preadv2(fd int, iovs [][]byte, offset int64, flags int) (n int, err error) {
2036
	iovecs := make([]Iovec, 0, minIovec)
2037
	iovecs = appendBytes(iovecs, iovs)
2038
	lo, hi := offs2lohi(offset)
2039
	n, err = preadv2(fd, iovecs, lo, hi, flags)
2040
	readvRacedetect(iovecs, n, err)
2041
	return n, err
2042
}
2043

2044
func readvRacedetect(iovecs []Iovec, n int, err error) {
2045
	if !raceenabled {
2046
		return
2047
	}
2048
	for i := 0; n > 0 && i < len(iovecs); i++ {
2049
		m := int(iovecs[i].Len)
2050
		if m > n {
2051
			m = n
2052
		}
2053
		n -= m
2054
		if m > 0 {
2055
			raceWriteRange(unsafe.Pointer(iovecs[i].Base), m)
2056
		}
2057
	}
2058
	if err == nil {
2059
		raceAcquire(unsafe.Pointer(&ioSync))
2060
	}
2061
}
2062

2063
func Writev(fd int, iovs [][]byte) (n int, err error) {
2064
	iovecs := make([]Iovec, 0, minIovec)
2065
	iovecs = appendBytes(iovecs, iovs)
2066
	if raceenabled {
2067
		raceReleaseMerge(unsafe.Pointer(&ioSync))
2068
	}
2069
	n, err = writev(fd, iovecs)
2070
	writevRacedetect(iovecs, n)
2071
	return n, err
2072
}
2073

2074
func Pwritev(fd int, iovs [][]byte, offset int64) (n int, err error) {
2075
	iovecs := make([]Iovec, 0, minIovec)
2076
	iovecs = appendBytes(iovecs, iovs)
2077
	if raceenabled {
2078
		raceReleaseMerge(unsafe.Pointer(&ioSync))
2079
	}
2080
	lo, hi := offs2lohi(offset)
2081
	n, err = pwritev(fd, iovecs, lo, hi)
2082
	writevRacedetect(iovecs, n)
2083
	return n, err
2084
}
2085

2086
func Pwritev2(fd int, iovs [][]byte, offset int64, flags int) (n int, err error) {
2087
	iovecs := make([]Iovec, 0, minIovec)
2088
	iovecs = appendBytes(iovecs, iovs)
2089
	if raceenabled {
2090
		raceReleaseMerge(unsafe.Pointer(&ioSync))
2091
	}
2092
	lo, hi := offs2lohi(offset)
2093
	n, err = pwritev2(fd, iovecs, lo, hi, flags)
2094
	writevRacedetect(iovecs, n)
2095
	return n, err
2096
}
2097

2098
func writevRacedetect(iovecs []Iovec, n int) {
2099
	if !raceenabled {
2100
		return
2101
	}
2102
	for i := 0; n > 0 && i < len(iovecs); i++ {
2103
		m := int(iovecs[i].Len)
2104
		if m > n {
2105
			m = n
2106
		}
2107
		n -= m
2108
		if m > 0 {
2109
			raceReadRange(unsafe.Pointer(iovecs[i].Base), m)
2110
		}
2111
	}
2112
}
2113

2114
// mmap varies by architecture; see syscall_linux_*.go.
2115
//sys	munmap(addr uintptr, length uintptr) (err error)
2116

2117
var mapper = &mmapper{
2118
	active: make(map[*byte][]byte),
2119
	mmap:   mmap,
2120
	munmap: munmap,
2121
}
2122

2123
func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) {
2124
	return mapper.Mmap(fd, offset, length, prot, flags)
2125
}
2126

2127
func Munmap(b []byte) (err error) {
2128
	return mapper.Munmap(b)
2129
}
2130

2131
//sys	Madvise(b []byte, advice int) (err error)
2132
//sys	Mprotect(b []byte, prot int) (err error)
2133
//sys	Mlock(b []byte) (err error)
2134
//sys	Mlockall(flags int) (err error)
2135
//sys	Msync(b []byte, flags int) (err error)
2136
//sys	Munlock(b []byte) (err error)
2137
//sys	Munlockall() (err error)
2138

2139
// Vmsplice splices user pages from a slice of Iovecs into a pipe specified by fd,
2140
// using the specified flags.
2141
func Vmsplice(fd int, iovs []Iovec, flags int) (int, error) {
2142
	var p unsafe.Pointer
2143
	if len(iovs) > 0 {
2144
		p = unsafe.Pointer(&iovs[0])
2145
	}
2146

2147
	n, _, errno := Syscall6(SYS_VMSPLICE, uintptr(fd), uintptr(p), uintptr(len(iovs)), uintptr(flags), 0, 0)
2148
	if errno != 0 {
2149
		return 0, syscall.Errno(errno)
2150
	}
2151

2152
	return int(n), nil
2153
}
2154

2155
func isGroupMember(gid int) bool {
2156
	groups, err := Getgroups()
2157
	if err != nil {
2158
		return false
2159
	}
2160

2161
	for _, g := range groups {
2162
		if g == gid {
2163
			return true
2164
		}
2165
	}
2166
	return false
2167
}
2168

2169
func isCapDacOverrideSet() bool {
2170
	hdr := CapUserHeader{Version: LINUX_CAPABILITY_VERSION_3}
2171
	data := [2]CapUserData{}
2172
	err := Capget(&hdr, &data[0])
2173

2174
	return err == nil && data[0].Effective&(1<<CAP_DAC_OVERRIDE) != 0
2175
}
2176

2177
//sys	faccessat(dirfd int, path string, mode uint32) (err error)
2178
//sys	Faccessat2(dirfd int, path string, mode uint32, flags int) (err error)
2179

2180
func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
2181
	if flags == 0 {
2182
		return faccessat(dirfd, path, mode)
2183
	}
2184

2185
	if err := Faccessat2(dirfd, path, mode, flags); err != ENOSYS && err != EPERM {
2186
		return err
2187
	}
2188

2189
	// The Linux kernel faccessat system call does not take any flags.
2190
	// The glibc faccessat implements the flags itself; see
2191
	// https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/unix/sysv/linux/faccessat.c;hb=HEAD
2192
	// Because people naturally expect syscall.Faccessat to act
2193
	// like C faccessat, we do the same.
2194

2195
	if flags & ^(AT_SYMLINK_NOFOLLOW|AT_EACCESS) != 0 {
2196
		return EINVAL
2197
	}
2198

2199
	var st Stat_t
2200
	if err := Fstatat(dirfd, path, &st, flags&AT_SYMLINK_NOFOLLOW); err != nil {
2201
		return err
2202
	}
2203

2204
	mode &= 7
2205
	if mode == 0 {
2206
		return nil
2207
	}
2208

2209
	var uid int
2210
	if flags&AT_EACCESS != 0 {
2211
		uid = Geteuid()
2212
		if uid != 0 && isCapDacOverrideSet() {
2213
			// If CAP_DAC_OVERRIDE is set, file access check is
2214
			// done by the kernel in the same way as for root
2215
			// (see generic_permission() in the Linux sources).
2216
			uid = 0
2217
		}
2218
	} else {
2219
		uid = Getuid()
2220
	}
2221

2222
	if uid == 0 {
2223
		if mode&1 == 0 {
2224
			// Root can read and write any file.
2225
			return nil
2226
		}
2227
		if st.Mode&0111 != 0 {
2228
			// Root can execute any file that anybody can execute.
2229
			return nil
2230
		}
2231
		return EACCES
2232
	}
2233

2234
	var fmode uint32
2235
	if uint32(uid) == st.Uid {
2236
		fmode = (st.Mode >> 6) & 7
2237
	} else {
2238
		var gid int
2239
		if flags&AT_EACCESS != 0 {
2240
			gid = Getegid()
2241
		} else {
2242
			gid = Getgid()
2243
		}
2244

2245
		if uint32(gid) == st.Gid || isGroupMember(int(st.Gid)) {
2246
			fmode = (st.Mode >> 3) & 7
2247
		} else {
2248
			fmode = st.Mode & 7
2249
		}
2250
	}
2251

2252
	if fmode&mode == mode {
2253
		return nil
2254
	}
2255

2256
	return EACCES
2257
}
2258

2259
//sys	nameToHandleAt(dirFD int, pathname string, fh *fileHandle, mountID *_C_int, flags int) (err error) = SYS_NAME_TO_HANDLE_AT
2260
//sys	openByHandleAt(mountFD int, fh *fileHandle, flags int) (fd int, err error) = SYS_OPEN_BY_HANDLE_AT
2261

2262
// fileHandle is the argument to nameToHandleAt and openByHandleAt. We
2263
// originally tried to generate it via unix/linux/types.go with "type
2264
// fileHandle C.struct_file_handle" but that generated empty structs
2265
// for mips64 and mips64le. Instead, hard code it for now (it's the
2266
// same everywhere else) until the mips64 generator issue is fixed.
2267
type fileHandle struct {
2268
	Bytes uint32
2269
	Type  int32
2270
}
2271

2272
// FileHandle represents the C struct file_handle used by
2273
// name_to_handle_at (see NameToHandleAt) and open_by_handle_at (see
2274
// OpenByHandleAt).
2275
type FileHandle struct {
2276
	*fileHandle
2277
}
2278

2279
// NewFileHandle constructs a FileHandle.
2280
func NewFileHandle(handleType int32, handle []byte) FileHandle {
2281
	const hdrSize = unsafe.Sizeof(fileHandle{})
2282
	buf := make([]byte, hdrSize+uintptr(len(handle)))
2283
	copy(buf[hdrSize:], handle)
2284
	fh := (*fileHandle)(unsafe.Pointer(&buf[0]))
2285
	fh.Type = handleType
2286
	fh.Bytes = uint32(len(handle))
2287
	return FileHandle{fh}
2288
}
2289

2290
func (fh *FileHandle) Size() int   { return int(fh.fileHandle.Bytes) }
2291
func (fh *FileHandle) Type() int32 { return fh.fileHandle.Type }
2292
func (fh *FileHandle) Bytes() []byte {
2293
	n := fh.Size()
2294
	if n == 0 {
2295
		return nil
2296
	}
2297
	return unsafe.Slice((*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(&fh.fileHandle.Type))+4)), n)
2298
}
2299

2300
// NameToHandleAt wraps the name_to_handle_at system call; it obtains
2301
// a handle for a path name.
2302
func NameToHandleAt(dirfd int, path string, flags int) (handle FileHandle, mountID int, err error) {
2303
	var mid _C_int
2304
	// Try first with a small buffer, assuming the handle will
2305
	// only be 32 bytes.
2306
	size := uint32(32 + unsafe.Sizeof(fileHandle{}))
2307
	didResize := false
2308
	for {
2309
		buf := make([]byte, size)
2310
		fh := (*fileHandle)(unsafe.Pointer(&buf[0]))
2311
		fh.Bytes = size - uint32(unsafe.Sizeof(fileHandle{}))
2312
		err = nameToHandleAt(dirfd, path, fh, &mid, flags)
2313
		if err == EOVERFLOW {
2314
			if didResize {
2315
				// We shouldn't need to resize more than once
2316
				return
2317
			}
2318
			didResize = true
2319
			size = fh.Bytes + uint32(unsafe.Sizeof(fileHandle{}))
2320
			continue
2321
		}
2322
		if err != nil {
2323
			return
2324
		}
2325
		return FileHandle{fh}, int(mid), nil
2326
	}
2327
}
2328

2329
// OpenByHandleAt wraps the open_by_handle_at system call; it opens a
2330
// file via a handle as previously returned by NameToHandleAt.
2331
func OpenByHandleAt(mountFD int, handle FileHandle, flags int) (fd int, err error) {
2332
	return openByHandleAt(mountFD, handle.fileHandle, flags)
2333
}
2334

2335
// Klogset wraps the sys_syslog system call; it sets console_loglevel to
2336
// the value specified by arg and passes a dummy pointer to bufp.
2337
func Klogset(typ int, arg int) (err error) {
2338
	var p unsafe.Pointer
2339
	_, _, errno := Syscall(SYS_SYSLOG, uintptr(typ), uintptr(p), uintptr(arg))
2340
	if errno != 0 {
2341
		return errnoErr(errno)
2342
	}
2343
	return nil
2344
}
2345

2346
// RemoteIovec is Iovec with the pointer replaced with an integer.
2347
// It is used for ProcessVMReadv and ProcessVMWritev, where the pointer
2348
// refers to a location in a different process' address space, which
2349
// would confuse the Go garbage collector.
2350
type RemoteIovec struct {
2351
	Base uintptr
2352
	Len  int
2353
}
2354

2355
//sys	ProcessVMReadv(pid int, localIov []Iovec, remoteIov []RemoteIovec, flags uint) (n int, err error) = SYS_PROCESS_VM_READV
2356
//sys	ProcessVMWritev(pid int, localIov []Iovec, remoteIov []RemoteIovec, flags uint) (n int, err error) = SYS_PROCESS_VM_WRITEV
2357

2358
//sys	PidfdOpen(pid int, flags int) (fd int, err error) = SYS_PIDFD_OPEN
2359
//sys	PidfdGetfd(pidfd int, targetfd int, flags int) (fd int, err error) = SYS_PIDFD_GETFD
2360
//sys	PidfdSendSignal(pidfd int, sig Signal, info *Siginfo, flags int) (err error) = SYS_PIDFD_SEND_SIGNAL
2361

2362
//sys	shmat(id int, addr uintptr, flag int) (ret uintptr, err error)
2363
//sys	shmctl(id int, cmd int, buf *SysvShmDesc) (result int, err error)
2364
//sys	shmdt(addr uintptr) (err error)
2365
//sys	shmget(key int, size int, flag int) (id int, err error)
2366

2367
//sys	getitimer(which int, currValue *Itimerval) (err error)
2368
//sys	setitimer(which int, newValue *Itimerval, oldValue *Itimerval) (err error)
2369

2370
// MakeItimerval creates an Itimerval from interval and value durations.
2371
func MakeItimerval(interval, value time.Duration) Itimerval {
2372
	return Itimerval{
2373
		Interval: NsecToTimeval(interval.Nanoseconds()),
2374
		Value:    NsecToTimeval(value.Nanoseconds()),
2375
	}
2376
}
2377

2378
// A value which may be passed to the which parameter for Getitimer and
2379
// Setitimer.
2380
type ItimerWhich int
2381

2382
// Possible which values for Getitimer and Setitimer.
2383
const (
2384
	ItimerReal    ItimerWhich = ITIMER_REAL
2385
	ItimerVirtual ItimerWhich = ITIMER_VIRTUAL
2386
	ItimerProf    ItimerWhich = ITIMER_PROF
2387
)
2388

2389
// Getitimer wraps getitimer(2) to return the current value of the timer
2390
// specified by which.
2391
func Getitimer(which ItimerWhich) (Itimerval, error) {
2392
	var it Itimerval
2393
	if err := getitimer(int(which), &it); err != nil {
2394
		return Itimerval{}, err
2395
	}
2396

2397
	return it, nil
2398
}
2399

2400
// Setitimer wraps setitimer(2) to arm or disarm the timer specified by which.
2401
// It returns the previous value of the timer.
2402
//
2403
// If the Itimerval argument is the zero value, the timer will be disarmed.
2404
func Setitimer(which ItimerWhich, it Itimerval) (Itimerval, error) {
2405
	var prev Itimerval
2406
	if err := setitimer(int(which), &it, &prev); err != nil {
2407
		return Itimerval{}, err
2408
	}
2409

2410
	return prev, nil
2411
}
2412

2413
//sysnb	rtSigprocmask(how int, set *Sigset_t, oldset *Sigset_t, sigsetsize uintptr) (err error) = SYS_RT_SIGPROCMASK
2414

2415
func PthreadSigmask(how int, set, oldset *Sigset_t) error {
2416
	if oldset != nil {
2417
		// Explicitly clear in case Sigset_t is larger than _C__NSIG.
2418
		*oldset = Sigset_t{}
2419
	}
2420
	return rtSigprocmask(how, set, oldset, _C__NSIG/8)
2421
}
2422

2423
/*
2424
 * Unimplemented
2425
 */
2426
// AfsSyscall
2427
// ArchPrctl
2428
// Brk
2429
// ClockNanosleep
2430
// ClockSettime
2431
// Clone
2432
// EpollCtlOld
2433
// EpollPwait
2434
// EpollWaitOld
2435
// Execve
2436
// Fork
2437
// Futex
2438
// GetKernelSyms
2439
// GetMempolicy
2440
// GetRobustList
2441
// GetThreadArea
2442
// Getpmsg
2443
// IoCancel
2444
// IoDestroy
2445
// IoGetevents
2446
// IoSetup
2447
// IoSubmit
2448
// IoprioGet
2449
// IoprioSet
2450
// KexecLoad
2451
// LookupDcookie
2452
// Mbind
2453
// MigratePages
2454
// Mincore
2455
// ModifyLdt
2456
// Mount
2457
// MovePages
2458
// MqGetsetattr
2459
// MqNotify
2460
// MqOpen
2461
// MqTimedreceive
2462
// MqTimedsend
2463
// MqUnlink
2464
// Mremap
2465
// Msgctl
2466
// Msgget
2467
// Msgrcv
2468
// Msgsnd
2469
// Nfsservctl
2470
// Personality
2471
// Pselect6
2472
// Ptrace
2473
// Putpmsg
2474
// Quotactl
2475
// Readahead
2476
// Readv
2477
// RemapFilePages
2478
// RestartSyscall
2479
// RtSigaction
2480
// RtSigpending
2481
// RtSigqueueinfo
2482
// RtSigreturn
2483
// RtSigsuspend
2484
// RtSigtimedwait
2485
// SchedGetPriorityMax
2486
// SchedGetPriorityMin
2487
// SchedGetparam
2488
// SchedGetscheduler
2489
// SchedRrGetInterval
2490
// SchedSetparam
2491
// SchedYield
2492
// Security
2493
// Semctl
2494
// Semget
2495
// Semop
2496
// Semtimedop
2497
// SetMempolicy
2498
// SetRobustList
2499
// SetThreadArea
2500
// SetTidAddress
2501
// Sigaltstack
2502
// Swapoff
2503
// Swapon
2504
// Sysfs
2505
// TimerCreate
2506
// TimerDelete
2507
// TimerGetoverrun
2508
// TimerGettime
2509
// TimerSettime
2510
// Tkill (obsolete)
2511
// Tuxcall
2512
// Umount2
2513
// Uselib
2514
// Utimensat
2515
// Vfork
2516
// Vhangup
2517
// Vserver
2518
// _Sysctl
2519