github.com/Kalvelign/golang-windows-sys-lib@v0.0.0-20221121121202-63da651435e1/unix/syscall_linux.go (about) 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 bytes := (*[len(pp.Path)]byte)(unsafe.Pointer(&pp.Path[0]))[0:n] 1019 sa.Name = string(bytes) 1020 return sa, nil 1021 1022 case AF_INET: 1023 proto, err := socketProtocol(fd) 1024 if err != nil { 1025 return nil, err 1026 } 1027 1028 switch proto { 1029 case IPPROTO_L2TP: 1030 pp := (*RawSockaddrL2TPIP)(unsafe.Pointer(rsa)) 1031 sa := new(SockaddrL2TPIP) 1032 sa.ConnId = pp.Conn_id 1033 sa.Addr = pp.Addr 1034 return sa, nil 1035 default: 1036 pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa)) 1037 sa := new(SockaddrInet4) 1038 p := (*[2]byte)(unsafe.Pointer(&pp.Port)) 1039 sa.Port = int(p[0])<<8 + int(p[1]) 1040 sa.Addr = pp.Addr 1041 return sa, nil 1042 } 1043 1044 case AF_INET6: 1045 proto, err := socketProtocol(fd) 1046 if err != nil { 1047 return nil, err 1048 } 1049 1050 switch proto { 1051 case IPPROTO_L2TP: 1052 pp := (*RawSockaddrL2TPIP6)(unsafe.Pointer(rsa)) 1053 sa := new(SockaddrL2TPIP6) 1054 sa.ConnId = pp.Conn_id 1055 sa.ZoneId = pp.Scope_id 1056 sa.Addr = pp.Addr 1057 return sa, nil 1058 default: 1059 pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa)) 1060 sa := new(SockaddrInet6) 1061 p := (*[2]byte)(unsafe.Pointer(&pp.Port)) 1062 sa.Port = int(p[0])<<8 + int(p[1]) 1063 sa.ZoneId = pp.Scope_id 1064 sa.Addr = pp.Addr 1065 return sa, nil 1066 } 1067 1068 case AF_VSOCK: 1069 pp := (*RawSockaddrVM)(unsafe.Pointer(rsa)) 1070 sa := &SockaddrVM{ 1071 CID: pp.Cid, 1072 Port: pp.Port, 1073 Flags: pp.Flags, 1074 } 1075 return sa, nil 1076 case AF_BLUETOOTH: 1077 proto, err := socketProtocol(fd) 1078 if err != nil { 1079 return nil, err 1080 } 1081 // only BTPROTO_L2CAP and BTPROTO_RFCOMM can accept connections 1082 switch proto { 1083 case BTPROTO_L2CAP: 1084 pp := (*RawSockaddrL2)(unsafe.Pointer(rsa)) 1085 sa := &SockaddrL2{ 1086 PSM: pp.Psm, 1087 CID: pp.Cid, 1088 Addr: pp.Bdaddr, 1089 AddrType: pp.Bdaddr_type, 1090 } 1091 return sa, nil 1092 case BTPROTO_RFCOMM: 1093 pp := (*RawSockaddrRFCOMM)(unsafe.Pointer(rsa)) 1094 sa := &SockaddrRFCOMM{ 1095 Channel: pp.Channel, 1096 Addr: pp.Bdaddr, 1097 } 1098 return sa, nil 1099 } 1100 case AF_XDP: 1101 pp := (*RawSockaddrXDP)(unsafe.Pointer(rsa)) 1102 sa := &SockaddrXDP{ 1103 Flags: pp.Flags, 1104 Ifindex: pp.Ifindex, 1105 QueueID: pp.Queue_id, 1106 SharedUmemFD: pp.Shared_umem_fd, 1107 } 1108 return sa, nil 1109 case AF_PPPOX: 1110 pp := (*RawSockaddrPPPoX)(unsafe.Pointer(rsa)) 1111 if binary.BigEndian.Uint32(pp[2:6]) != px_proto_oe { 1112 return nil, EINVAL 1113 } 1114 sa := &SockaddrPPPoE{ 1115 SID: binary.BigEndian.Uint16(pp[6:8]), 1116 Remote: pp[8:14], 1117 } 1118 for i := 14; i < 14+IFNAMSIZ; i++ { 1119 if pp[i] == 0 { 1120 sa.Dev = string(pp[14:i]) 1121 break 1122 } 1123 } 1124 return sa, nil 1125 case AF_TIPC: 1126 pp := (*RawSockaddrTIPC)(unsafe.Pointer(rsa)) 1127 1128 sa := &SockaddrTIPC{ 1129 Scope: int(pp.Scope), 1130 } 1131 1132 // Determine which union variant is present in pp.Addr by checking 1133 // pp.Addrtype. 1134 switch pp.Addrtype { 1135 case TIPC_SERVICE_RANGE: 1136 sa.Addr = (*TIPCServiceRange)(unsafe.Pointer(&pp.Addr)) 1137 case TIPC_SERVICE_ADDR: 1138 sa.Addr = (*TIPCServiceName)(unsafe.Pointer(&pp.Addr)) 1139 case TIPC_SOCKET_ADDR: 1140 sa.Addr = (*TIPCSocketAddr)(unsafe.Pointer(&pp.Addr)) 1141 default: 1142 return nil, EINVAL 1143 } 1144 1145 return sa, nil 1146 case AF_IUCV: 1147 pp := (*RawSockaddrIUCV)(unsafe.Pointer(rsa)) 1148 1149 var user [8]byte 1150 var name [8]byte 1151 1152 for i := 0; i < 8; i++ { 1153 user[i] = byte(pp.User_id[i]) 1154 name[i] = byte(pp.Name[i]) 1155 } 1156 1157 sa := &SockaddrIUCV{ 1158 UserID: string(user[:]), 1159 Name: string(name[:]), 1160 } 1161 return sa, nil 1162 1163 case AF_CAN: 1164 proto, err := socketProtocol(fd) 1165 if err != nil { 1166 return nil, err 1167 } 1168 1169 pp := (*RawSockaddrCAN)(unsafe.Pointer(rsa)) 1170 1171 switch proto { 1172 case CAN_J1939: 1173 sa := &SockaddrCANJ1939{ 1174 Ifindex: int(pp.Ifindex), 1175 } 1176 name := (*[8]byte)(unsafe.Pointer(&sa.Name)) 1177 for i := 0; i < 8; i++ { 1178 name[i] = pp.Addr[i] 1179 } 1180 pgn := (*[4]byte)(unsafe.Pointer(&sa.PGN)) 1181 for i := 0; i < 4; i++ { 1182 pgn[i] = pp.Addr[i+8] 1183 } 1184 addr := (*[1]byte)(unsafe.Pointer(&sa.Addr)) 1185 addr[0] = pp.Addr[12] 1186 return sa, nil 1187 default: 1188 sa := &SockaddrCAN{ 1189 Ifindex: int(pp.Ifindex), 1190 } 1191 rx := (*[4]byte)(unsafe.Pointer(&sa.RxID)) 1192 for i := 0; i < 4; i++ { 1193 rx[i] = pp.Addr[i] 1194 } 1195 tx := (*[4]byte)(unsafe.Pointer(&sa.TxID)) 1196 for i := 0; i < 4; i++ { 1197 tx[i] = pp.Addr[i+4] 1198 } 1199 return sa, nil 1200 } 1201 case AF_NFC: 1202 proto, err := socketProtocol(fd) 1203 if err != nil { 1204 return nil, err 1205 } 1206 switch proto { 1207 case NFC_SOCKPROTO_RAW: 1208 pp := (*RawSockaddrNFC)(unsafe.Pointer(rsa)) 1209 sa := &SockaddrNFC{ 1210 DeviceIdx: pp.Dev_idx, 1211 TargetIdx: pp.Target_idx, 1212 NFCProtocol: pp.Nfc_protocol, 1213 } 1214 return sa, nil 1215 case NFC_SOCKPROTO_LLCP: 1216 pp := (*RawSockaddrNFCLLCP)(unsafe.Pointer(rsa)) 1217 if uint64(pp.Service_name_len) > uint64(len(pp.Service_name)) { 1218 return nil, EINVAL 1219 } 1220 sa := &SockaddrNFCLLCP{ 1221 DeviceIdx: pp.Dev_idx, 1222 TargetIdx: pp.Target_idx, 1223 NFCProtocol: pp.Nfc_protocol, 1224 DestinationSAP: pp.Dsap, 1225 SourceSAP: pp.Ssap, 1226 ServiceName: string(pp.Service_name[:pp.Service_name_len]), 1227 } 1228 return sa, nil 1229 default: 1230 return nil, EINVAL 1231 } 1232 } 1233 return nil, EAFNOSUPPORT 1234 } 1235 1236 func Accept(fd int) (nfd int, sa Sockaddr, err error) { 1237 var rsa RawSockaddrAny 1238 var len _Socklen = SizeofSockaddrAny 1239 nfd, err = accept4(fd, &rsa, &len, 0) 1240 if err != nil { 1241 return 1242 } 1243 sa, err = anyToSockaddr(fd, &rsa) 1244 if err != nil { 1245 Close(nfd) 1246 nfd = 0 1247 } 1248 return 1249 } 1250 1251 func Accept4(fd int, flags int) (nfd int, sa Sockaddr, err error) { 1252 var rsa RawSockaddrAny 1253 var len _Socklen = SizeofSockaddrAny 1254 nfd, err = accept4(fd, &rsa, &len, flags) 1255 if err != nil { 1256 return 1257 } 1258 if len > SizeofSockaddrAny { 1259 panic("RawSockaddrAny too small") 1260 } 1261 sa, err = anyToSockaddr(fd, &rsa) 1262 if err != nil { 1263 Close(nfd) 1264 nfd = 0 1265 } 1266 return 1267 } 1268 1269 func Getsockname(fd int) (sa Sockaddr, err error) { 1270 var rsa RawSockaddrAny 1271 var len _Socklen = SizeofSockaddrAny 1272 if err = getsockname(fd, &rsa, &len); err != nil { 1273 return 1274 } 1275 return anyToSockaddr(fd, &rsa) 1276 } 1277 1278 func GetsockoptIPMreqn(fd, level, opt int) (*IPMreqn, error) { 1279 var value IPMreqn 1280 vallen := _Socklen(SizeofIPMreqn) 1281 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) 1282 return &value, err 1283 } 1284 1285 func GetsockoptUcred(fd, level, opt int) (*Ucred, error) { 1286 var value Ucred 1287 vallen := _Socklen(SizeofUcred) 1288 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) 1289 return &value, err 1290 } 1291 1292 func GetsockoptTCPInfo(fd, level, opt int) (*TCPInfo, error) { 1293 var value TCPInfo 1294 vallen := _Socklen(SizeofTCPInfo) 1295 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) 1296 return &value, err 1297 } 1298 1299 // GetsockoptString returns the string value of the socket option opt for the 1300 // socket associated with fd at the given socket level. 1301 func GetsockoptString(fd, level, opt int) (string, error) { 1302 buf := make([]byte, 256) 1303 vallen := _Socklen(len(buf)) 1304 err := getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen) 1305 if err != nil { 1306 if err == ERANGE { 1307 buf = make([]byte, vallen) 1308 err = getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen) 1309 } 1310 if err != nil { 1311 return "", err 1312 } 1313 } 1314 return string(buf[:vallen-1]), nil 1315 } 1316 1317 func GetsockoptTpacketStats(fd, level, opt int) (*TpacketStats, error) { 1318 var value TpacketStats 1319 vallen := _Socklen(SizeofTpacketStats) 1320 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) 1321 return &value, err 1322 } 1323 1324 func GetsockoptTpacketStatsV3(fd, level, opt int) (*TpacketStatsV3, error) { 1325 var value TpacketStatsV3 1326 vallen := _Socklen(SizeofTpacketStatsV3) 1327 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) 1328 return &value, err 1329 } 1330 1331 func SetsockoptIPMreqn(fd, level, opt int, mreq *IPMreqn) (err error) { 1332 return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq)) 1333 } 1334 1335 func SetsockoptPacketMreq(fd, level, opt int, mreq *PacketMreq) error { 1336 return setsockopt(fd, level, opt, unsafe.Pointer(mreq), unsafe.Sizeof(*mreq)) 1337 } 1338 1339 // SetsockoptSockFprog attaches a classic BPF or an extended BPF program to a 1340 // socket to filter incoming packets. See 'man 7 socket' for usage information. 1341 func SetsockoptSockFprog(fd, level, opt int, fprog *SockFprog) error { 1342 return setsockopt(fd, level, opt, unsafe.Pointer(fprog), unsafe.Sizeof(*fprog)) 1343 } 1344 1345 func SetsockoptCanRawFilter(fd, level, opt int, filter []CanFilter) error { 1346 var p unsafe.Pointer 1347 if len(filter) > 0 { 1348 p = unsafe.Pointer(&filter[0]) 1349 } 1350 return setsockopt(fd, level, opt, p, uintptr(len(filter)*SizeofCanFilter)) 1351 } 1352 1353 func SetsockoptTpacketReq(fd, level, opt int, tp *TpacketReq) error { 1354 return setsockopt(fd, level, opt, unsafe.Pointer(tp), unsafe.Sizeof(*tp)) 1355 } 1356 1357 func SetsockoptTpacketReq3(fd, level, opt int, tp *TpacketReq3) error { 1358 return setsockopt(fd, level, opt, unsafe.Pointer(tp), unsafe.Sizeof(*tp)) 1359 } 1360 1361 func SetsockoptTCPRepairOpt(fd, level, opt int, o []TCPRepairOpt) (err error) { 1362 if len(o) == 0 { 1363 return EINVAL 1364 } 1365 return setsockopt(fd, level, opt, unsafe.Pointer(&o[0]), uintptr(SizeofTCPRepairOpt*len(o))) 1366 } 1367 1368 // Keyctl Commands (http://man7.org/linux/man-pages/man2/keyctl.2.html) 1369 1370 // KeyctlInt calls keyctl commands in which each argument is an int. 1371 // These commands are KEYCTL_REVOKE, KEYCTL_CHOWN, KEYCTL_CLEAR, KEYCTL_LINK, 1372 // KEYCTL_UNLINK, KEYCTL_NEGATE, KEYCTL_SET_REQKEY_KEYRING, KEYCTL_SET_TIMEOUT, 1373 // KEYCTL_ASSUME_AUTHORITY, KEYCTL_SESSION_TO_PARENT, KEYCTL_REJECT, 1374 // KEYCTL_INVALIDATE, and KEYCTL_GET_PERSISTENT. 1375 //sys KeyctlInt(cmd int, arg2 int, arg3 int, arg4 int, arg5 int) (ret int, err error) = SYS_KEYCTL 1376 1377 // KeyctlBuffer calls keyctl commands in which the third and fourth 1378 // arguments are a buffer and its length, respectively. 1379 // These commands are KEYCTL_UPDATE, KEYCTL_READ, and KEYCTL_INSTANTIATE. 1380 //sys KeyctlBuffer(cmd int, arg2 int, buf []byte, arg5 int) (ret int, err error) = SYS_KEYCTL 1381 1382 // KeyctlString calls keyctl commands which return a string. 1383 // These commands are KEYCTL_DESCRIBE and KEYCTL_GET_SECURITY. 1384 func KeyctlString(cmd int, id int) (string, error) { 1385 // We must loop as the string data may change in between the syscalls. 1386 // We could allocate a large buffer here to reduce the chance that the 1387 // syscall needs to be called twice; however, this is unnecessary as 1388 // the performance loss is negligible. 1389 var buffer []byte 1390 for { 1391 // Try to fill the buffer with data 1392 length, err := KeyctlBuffer(cmd, id, buffer, 0) 1393 if err != nil { 1394 return "", err 1395 } 1396 1397 // Check if the data was written 1398 if length <= len(buffer) { 1399 // Exclude the null terminator 1400 return string(buffer[:length-1]), nil 1401 } 1402 1403 // Make a bigger buffer if needed 1404 buffer = make([]byte, length) 1405 } 1406 } 1407 1408 // Keyctl commands with special signatures. 1409 1410 // KeyctlGetKeyringID implements the KEYCTL_GET_KEYRING_ID command. 1411 // See the full documentation at: 1412 // http://man7.org/linux/man-pages/man3/keyctl_get_keyring_ID.3.html 1413 func KeyctlGetKeyringID(id int, create bool) (ringid int, err error) { 1414 createInt := 0 1415 if create { 1416 createInt = 1 1417 } 1418 return KeyctlInt(KEYCTL_GET_KEYRING_ID, id, createInt, 0, 0) 1419 } 1420 1421 // KeyctlSetperm implements the KEYCTL_SETPERM command. The perm value is the 1422 // key handle permission mask as described in the "keyctl setperm" section of 1423 // http://man7.org/linux/man-pages/man1/keyctl.1.html. 1424 // See the full documentation at: 1425 // http://man7.org/linux/man-pages/man3/keyctl_setperm.3.html 1426 func KeyctlSetperm(id int, perm uint32) error { 1427 _, err := KeyctlInt(KEYCTL_SETPERM, id, int(perm), 0, 0) 1428 return err 1429 } 1430 1431 //sys keyctlJoin(cmd int, arg2 string) (ret int, err error) = SYS_KEYCTL 1432 1433 // KeyctlJoinSessionKeyring implements the KEYCTL_JOIN_SESSION_KEYRING command. 1434 // See the full documentation at: 1435 // http://man7.org/linux/man-pages/man3/keyctl_join_session_keyring.3.html 1436 func KeyctlJoinSessionKeyring(name string) (ringid int, err error) { 1437 return keyctlJoin(KEYCTL_JOIN_SESSION_KEYRING, name) 1438 } 1439 1440 //sys keyctlSearch(cmd int, arg2 int, arg3 string, arg4 string, arg5 int) (ret int, err error) = SYS_KEYCTL 1441 1442 // KeyctlSearch implements the KEYCTL_SEARCH command. 1443 // See the full documentation at: 1444 // http://man7.org/linux/man-pages/man3/keyctl_search.3.html 1445 func KeyctlSearch(ringid int, keyType, description string, destRingid int) (id int, err error) { 1446 return keyctlSearch(KEYCTL_SEARCH, ringid, keyType, description, destRingid) 1447 } 1448 1449 //sys keyctlIOV(cmd int, arg2 int, payload []Iovec, arg5 int) (err error) = SYS_KEYCTL 1450 1451 // KeyctlInstantiateIOV implements the KEYCTL_INSTANTIATE_IOV command. This 1452 // command is similar to KEYCTL_INSTANTIATE, except that the payload is a slice 1453 // of Iovec (each of which represents a buffer) instead of a single buffer. 1454 // See the full documentation at: 1455 // http://man7.org/linux/man-pages/man3/keyctl_instantiate_iov.3.html 1456 func KeyctlInstantiateIOV(id int, payload []Iovec, ringid int) error { 1457 return keyctlIOV(KEYCTL_INSTANTIATE_IOV, id, payload, ringid) 1458 } 1459 1460 //sys keyctlDH(cmd int, arg2 *KeyctlDHParams, buf []byte) (ret int, err error) = SYS_KEYCTL 1461 1462 // KeyctlDHCompute implements the KEYCTL_DH_COMPUTE command. This command 1463 // computes a Diffie-Hellman shared secret based on the provide params. The 1464 // secret is written to the provided buffer and the returned size is the number 1465 // of bytes written (returning an error if there is insufficient space in the 1466 // buffer). If a nil buffer is passed in, this function returns the minimum 1467 // buffer length needed to store the appropriate data. Note that this differs 1468 // from KEYCTL_READ's behavior which always returns the requested payload size. 1469 // See the full documentation at: 1470 // http://man7.org/linux/man-pages/man3/keyctl_dh_compute.3.html 1471 func KeyctlDHCompute(params *KeyctlDHParams, buffer []byte) (size int, err error) { 1472 return keyctlDH(KEYCTL_DH_COMPUTE, params, buffer) 1473 } 1474 1475 // KeyctlRestrictKeyring implements the KEYCTL_RESTRICT_KEYRING command. This 1476 // command limits the set of keys that can be linked to the keyring, regardless 1477 // of keyring permissions. The command requires the "setattr" permission. 1478 // 1479 // When called with an empty keyType the command locks the keyring, preventing 1480 // any further keys from being linked to the keyring. 1481 // 1482 // The "asymmetric" keyType defines restrictions requiring key payloads to be 1483 // DER encoded X.509 certificates signed by keys in another keyring. Restrictions 1484 // for "asymmetric" include "builtin_trusted", "builtin_and_secondary_trusted", 1485 // "key_or_keyring:<key>", and "key_or_keyring:<key>:chain". 1486 // 1487 // As of Linux 4.12, only the "asymmetric" keyType defines type-specific 1488 // restrictions. 1489 // 1490 // See the full documentation at: 1491 // http://man7.org/linux/man-pages/man3/keyctl_restrict_keyring.3.html 1492 // http://man7.org/linux/man-pages/man2/keyctl.2.html 1493 func KeyctlRestrictKeyring(ringid int, keyType string, restriction string) error { 1494 if keyType == "" { 1495 return keyctlRestrictKeyring(KEYCTL_RESTRICT_KEYRING, ringid) 1496 } 1497 return keyctlRestrictKeyringByType(KEYCTL_RESTRICT_KEYRING, ringid, keyType, restriction) 1498 } 1499 1500 //sys keyctlRestrictKeyringByType(cmd int, arg2 int, keyType string, restriction string) (err error) = SYS_KEYCTL 1501 //sys keyctlRestrictKeyring(cmd int, arg2 int) (err error) = SYS_KEYCTL 1502 1503 func recvmsgRaw(fd int, iov []Iovec, oob []byte, flags int, rsa *RawSockaddrAny) (n, oobn int, recvflags int, err error) { 1504 var msg Msghdr 1505 msg.Name = (*byte)(unsafe.Pointer(rsa)) 1506 msg.Namelen = uint32(SizeofSockaddrAny) 1507 var dummy byte 1508 if len(oob) > 0 { 1509 if emptyIovecs(iov) { 1510 var sockType int 1511 sockType, err = GetsockoptInt(fd, SOL_SOCKET, SO_TYPE) 1512 if err != nil { 1513 return 1514 } 1515 // receive at least one normal byte 1516 if sockType != SOCK_DGRAM { 1517 var iova [1]Iovec 1518 iova[0].Base = &dummy 1519 iova[0].SetLen(1) 1520 iov = iova[:] 1521 } 1522 } 1523 msg.Control = &oob[0] 1524 msg.SetControllen(len(oob)) 1525 } 1526 if len(iov) > 0 { 1527 msg.Iov = &iov[0] 1528 msg.SetIovlen(len(iov)) 1529 } 1530 if n, err = recvmsg(fd, &msg, flags); err != nil { 1531 return 1532 } 1533 oobn = int(msg.Controllen) 1534 recvflags = int(msg.Flags) 1535 return 1536 } 1537 1538 func sendmsgN(fd int, iov []Iovec, oob []byte, ptr unsafe.Pointer, salen _Socklen, flags int) (n int, err error) { 1539 var msg Msghdr 1540 msg.Name = (*byte)(ptr) 1541 msg.Namelen = uint32(salen) 1542 var dummy byte 1543 var empty bool 1544 if len(oob) > 0 { 1545 empty = emptyIovecs(iov) 1546 if empty { 1547 var sockType int 1548 sockType, err = GetsockoptInt(fd, SOL_SOCKET, SO_TYPE) 1549 if err != nil { 1550 return 0, err 1551 } 1552 // send at least one normal byte 1553 if sockType != SOCK_DGRAM { 1554 var iova [1]Iovec 1555 iova[0].Base = &dummy 1556 iova[0].SetLen(1) 1557 iov = iova[:] 1558 } 1559 } 1560 msg.Control = &oob[0] 1561 msg.SetControllen(len(oob)) 1562 } 1563 if len(iov) > 0 { 1564 msg.Iov = &iov[0] 1565 msg.SetIovlen(len(iov)) 1566 } 1567 if n, err = sendmsg(fd, &msg, flags); err != nil { 1568 return 0, err 1569 } 1570 if len(oob) > 0 && empty { 1571 n = 0 1572 } 1573 return n, nil 1574 } 1575 1576 // BindToDevice binds the socket associated with fd to device. 1577 func BindToDevice(fd int, device string) (err error) { 1578 return SetsockoptString(fd, SOL_SOCKET, SO_BINDTODEVICE, device) 1579 } 1580 1581 //sys ptrace(request int, pid int, addr uintptr, data uintptr) (err error) 1582 1583 func ptracePeek(req int, pid int, addr uintptr, out []byte) (count int, err error) { 1584 // The peek requests are machine-size oriented, so we wrap it 1585 // to retrieve arbitrary-length data. 1586 1587 // The ptrace syscall differs from glibc's ptrace. 1588 // Peeks returns the word in *data, not as the return value. 1589 1590 var buf [SizeofPtr]byte 1591 1592 // Leading edge. PEEKTEXT/PEEKDATA don't require aligned 1593 // access (PEEKUSER warns that it might), but if we don't 1594 // align our reads, we might straddle an unmapped page 1595 // boundary and not get the bytes leading up to the page 1596 // boundary. 1597 n := 0 1598 if addr%SizeofPtr != 0 { 1599 err = ptrace(req, pid, addr-addr%SizeofPtr, uintptr(unsafe.Pointer(&buf[0]))) 1600 if err != nil { 1601 return 0, err 1602 } 1603 n += copy(out, buf[addr%SizeofPtr:]) 1604 out = out[n:] 1605 } 1606 1607 // Remainder. 1608 for len(out) > 0 { 1609 // We use an internal buffer to guarantee alignment. 1610 // It's not documented if this is necessary, but we're paranoid. 1611 err = ptrace(req, pid, addr+uintptr(n), uintptr(unsafe.Pointer(&buf[0]))) 1612 if err != nil { 1613 return n, err 1614 } 1615 copied := copy(out, buf[0:]) 1616 n += copied 1617 out = out[copied:] 1618 } 1619 1620 return n, nil 1621 } 1622 1623 func PtracePeekText(pid int, addr uintptr, out []byte) (count int, err error) { 1624 return ptracePeek(PTRACE_PEEKTEXT, pid, addr, out) 1625 } 1626 1627 func PtracePeekData(pid int, addr uintptr, out []byte) (count int, err error) { 1628 return ptracePeek(PTRACE_PEEKDATA, pid, addr, out) 1629 } 1630 1631 func PtracePeekUser(pid int, addr uintptr, out []byte) (count int, err error) { 1632 return ptracePeek(PTRACE_PEEKUSR, pid, addr, out) 1633 } 1634 1635 func ptracePoke(pokeReq int, peekReq int, pid int, addr uintptr, data []byte) (count int, err error) { 1636 // As for ptracePeek, we need to align our accesses to deal 1637 // with the possibility of straddling an invalid page. 1638 1639 // Leading edge. 1640 n := 0 1641 if addr%SizeofPtr != 0 { 1642 var buf [SizeofPtr]byte 1643 err = ptrace(peekReq, pid, addr-addr%SizeofPtr, uintptr(unsafe.Pointer(&buf[0]))) 1644 if err != nil { 1645 return 0, err 1646 } 1647 n += copy(buf[addr%SizeofPtr:], data) 1648 word := *((*uintptr)(unsafe.Pointer(&buf[0]))) 1649 err = ptrace(pokeReq, pid, addr-addr%SizeofPtr, word) 1650 if err != nil { 1651 return 0, err 1652 } 1653 data = data[n:] 1654 } 1655 1656 // Interior. 1657 for len(data) > SizeofPtr { 1658 word := *((*uintptr)(unsafe.Pointer(&data[0]))) 1659 err = ptrace(pokeReq, pid, addr+uintptr(n), word) 1660 if err != nil { 1661 return n, err 1662 } 1663 n += SizeofPtr 1664 data = data[SizeofPtr:] 1665 } 1666 1667 // Trailing edge. 1668 if len(data) > 0 { 1669 var buf [SizeofPtr]byte 1670 err = ptrace(peekReq, pid, addr+uintptr(n), uintptr(unsafe.Pointer(&buf[0]))) 1671 if err != nil { 1672 return n, err 1673 } 1674 copy(buf[0:], data) 1675 word := *((*uintptr)(unsafe.Pointer(&buf[0]))) 1676 err = ptrace(pokeReq, pid, addr+uintptr(n), word) 1677 if err != nil { 1678 return n, err 1679 } 1680 n += len(data) 1681 } 1682 1683 return n, nil 1684 } 1685 1686 func PtracePokeText(pid int, addr uintptr, data []byte) (count int, err error) { 1687 return ptracePoke(PTRACE_POKETEXT, PTRACE_PEEKTEXT, pid, addr, data) 1688 } 1689 1690 func PtracePokeData(pid int, addr uintptr, data []byte) (count int, err error) { 1691 return ptracePoke(PTRACE_POKEDATA, PTRACE_PEEKDATA, pid, addr, data) 1692 } 1693 1694 func PtracePokeUser(pid int, addr uintptr, data []byte) (count int, err error) { 1695 return ptracePoke(PTRACE_POKEUSR, PTRACE_PEEKUSR, pid, addr, data) 1696 } 1697 1698 func PtraceGetRegs(pid int, regsout *PtraceRegs) (err error) { 1699 return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout))) 1700 } 1701 1702 func PtraceSetRegs(pid int, regs *PtraceRegs) (err error) { 1703 return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs))) 1704 } 1705 1706 func PtraceSetOptions(pid int, options int) (err error) { 1707 return ptrace(PTRACE_SETOPTIONS, pid, 0, uintptr(options)) 1708 } 1709 1710 func PtraceGetEventMsg(pid int) (msg uint, err error) { 1711 var data _C_long 1712 err = ptrace(PTRACE_GETEVENTMSG, pid, 0, uintptr(unsafe.Pointer(&data))) 1713 msg = uint(data) 1714 return 1715 } 1716 1717 func PtraceCont(pid int, signal int) (err error) { 1718 return ptrace(PTRACE_CONT, pid, 0, uintptr(signal)) 1719 } 1720 1721 func PtraceSyscall(pid int, signal int) (err error) { 1722 return ptrace(PTRACE_SYSCALL, pid, 0, uintptr(signal)) 1723 } 1724 1725 func PtraceSingleStep(pid int) (err error) { return ptrace(PTRACE_SINGLESTEP, pid, 0, 0) } 1726 1727 func PtraceInterrupt(pid int) (err error) { return ptrace(PTRACE_INTERRUPT, pid, 0, 0) } 1728 1729 func PtraceAttach(pid int) (err error) { return ptrace(PTRACE_ATTACH, pid, 0, 0) } 1730 1731 func PtraceSeize(pid int) (err error) { return ptrace(PTRACE_SEIZE, pid, 0, 0) } 1732 1733 func PtraceDetach(pid int) (err error) { return ptrace(PTRACE_DETACH, pid, 0, 0) } 1734 1735 //sys reboot(magic1 uint, magic2 uint, cmd int, arg string) (err error) 1736 1737 func Reboot(cmd int) (err error) { 1738 return reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, cmd, "") 1739 } 1740 1741 func direntIno(buf []byte) (uint64, bool) { 1742 return readInt(buf, unsafe.Offsetof(Dirent{}.Ino), unsafe.Sizeof(Dirent{}.Ino)) 1743 } 1744 1745 func direntReclen(buf []byte) (uint64, bool) { 1746 return readInt(buf, unsafe.Offsetof(Dirent{}.Reclen), unsafe.Sizeof(Dirent{}.Reclen)) 1747 } 1748 1749 func direntNamlen(buf []byte) (uint64, bool) { 1750 reclen, ok := direntReclen(buf) 1751 if !ok { 1752 return 0, false 1753 } 1754 return reclen - uint64(unsafe.Offsetof(Dirent{}.Name)), true 1755 } 1756 1757 //sys mount(source string, target string, fstype string, flags uintptr, data *byte) (err error) 1758 1759 func Mount(source string, target string, fstype string, flags uintptr, data string) (err error) { 1760 // Certain file systems get rather angry and EINVAL if you give 1761 // them an empty string of data, rather than NULL. 1762 if data == "" { 1763 return mount(source, target, fstype, flags, nil) 1764 } 1765 datap, err := BytePtrFromString(data) 1766 if err != nil { 1767 return err 1768 } 1769 return mount(source, target, fstype, flags, datap) 1770 } 1771 1772 //sys mountSetattr(dirfd int, pathname string, flags uint, attr *MountAttr, size uintptr) (err error) = SYS_MOUNT_SETATTR 1773 1774 // MountSetattr is a wrapper for mount_setattr(2). 1775 // https://man7.org/linux/man-pages/man2/mount_setattr.2.html 1776 // 1777 // Requires kernel >= 5.12. 1778 func MountSetattr(dirfd int, pathname string, flags uint, attr *MountAttr) error { 1779 return mountSetattr(dirfd, pathname, flags, attr, unsafe.Sizeof(*attr)) 1780 } 1781 1782 func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) { 1783 if raceenabled { 1784 raceReleaseMerge(unsafe.Pointer(&ioSync)) 1785 } 1786 return sendfile(outfd, infd, offset, count) 1787 } 1788 1789 // Sendto 1790 // Recvfrom 1791 // Socketpair 1792 1793 /* 1794 * Direct access 1795 */ 1796 //sys Acct(path string) (err error) 1797 //sys AddKey(keyType string, description string, payload []byte, ringid int) (id int, err error) 1798 //sys Adjtimex(buf *Timex) (state int, err error) 1799 //sysnb Capget(hdr *CapUserHeader, data *CapUserData) (err error) 1800 //sysnb Capset(hdr *CapUserHeader, data *CapUserData) (err error) 1801 //sys Chdir(path string) (err error) 1802 //sys Chroot(path string) (err error) 1803 //sys ClockGetres(clockid int32, res *Timespec) (err error) 1804 //sys ClockGettime(clockid int32, time *Timespec) (err error) 1805 //sys ClockNanosleep(clockid int32, flags int, request *Timespec, remain *Timespec) (err error) 1806 //sys Close(fd int) (err error) 1807 //sys CloseRange(first uint, last uint, flags uint) (err error) 1808 //sys CopyFileRange(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int, err error) 1809 //sys DeleteModule(name string, flags int) (err error) 1810 //sys Dup(oldfd int) (fd int, err error) 1811 1812 func Dup2(oldfd, newfd int) error { 1813 return Dup3(oldfd, newfd, 0) 1814 } 1815 1816 //sys Dup3(oldfd int, newfd int, flags int) (err error) 1817 //sysnb EpollCreate1(flag int) (fd int, err error) 1818 //sysnb EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) 1819 //sys Eventfd(initval uint, flags int) (fd int, err error) = SYS_EVENTFD2 1820 //sys Exit(code int) = SYS_EXIT_GROUP 1821 //sys Fallocate(fd int, mode uint32, off int64, len int64) (err error) 1822 //sys Fchdir(fd int) (err error) 1823 //sys Fchmod(fd int, mode uint32) (err error) 1824 //sys Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) 1825 //sys Fdatasync(fd int) (err error) 1826 //sys Fgetxattr(fd int, attr string, dest []byte) (sz int, err error) 1827 //sys FinitModule(fd int, params string, flags int) (err error) 1828 //sys Flistxattr(fd int, dest []byte) (sz int, err error) 1829 //sys Flock(fd int, how int) (err error) 1830 //sys Fremovexattr(fd int, attr string) (err error) 1831 //sys Fsetxattr(fd int, attr string, dest []byte, flags int) (err error) 1832 //sys Fsync(fd int) (err error) 1833 //sys Fsmount(fd int, flags int, mountAttrs int) (fsfd int, err error) 1834 //sys Fsopen(fsName string, flags int) (fd int, err error) 1835 //sys Fspick(dirfd int, pathName string, flags int) (fd int, err error) 1836 //sys Getdents(fd int, buf []byte) (n int, err error) = SYS_GETDENTS64 1837 //sysnb Getpgid(pid int) (pgid int, err error) 1838 1839 func Getpgrp() (pid int) { 1840 pid, _ = Getpgid(0) 1841 return 1842 } 1843 1844 //sysnb Getpid() (pid int) 1845 //sysnb Getppid() (ppid int) 1846 //sys Getpriority(which int, who int) (prio int, err error) 1847 //sys Getrandom(buf []byte, flags int) (n int, err error) 1848 //sysnb Getrusage(who int, rusage *Rusage) (err error) 1849 //sysnb Getsid(pid int) (sid int, err error) 1850 //sysnb Gettid() (tid int) 1851 //sys Getxattr(path string, attr string, dest []byte) (sz int, err error) 1852 //sys InitModule(moduleImage []byte, params string) (err error) 1853 //sys InotifyAddWatch(fd int, pathname string, mask uint32) (watchdesc int, err error) 1854 //sysnb InotifyInit1(flags int) (fd int, err error) 1855 //sysnb InotifyRmWatch(fd int, watchdesc uint32) (success int, err error) 1856 //sysnb Kill(pid int, sig syscall.Signal) (err error) 1857 //sys Klogctl(typ int, buf []byte) (n int, err error) = SYS_SYSLOG 1858 //sys Lgetxattr(path string, attr string, dest []byte) (sz int, err error) 1859 //sys Listxattr(path string, dest []byte) (sz int, err error) 1860 //sys Llistxattr(path string, dest []byte) (sz int, err error) 1861 //sys Lremovexattr(path string, attr string) (err error) 1862 //sys Lsetxattr(path string, attr string, data []byte, flags int) (err error) 1863 //sys MemfdCreate(name string, flags int) (fd int, err error) 1864 //sys Mkdirat(dirfd int, path string, mode uint32) (err error) 1865 //sys Mknodat(dirfd int, path string, mode uint32, dev int) (err error) 1866 //sys MoveMount(fromDirfd int, fromPathName string, toDirfd int, toPathName string, flags int) (err error) 1867 //sys Nanosleep(time *Timespec, leftover *Timespec) (err error) 1868 //sys OpenTree(dfd int, fileName string, flags uint) (r int, err error) 1869 //sys PerfEventOpen(attr *PerfEventAttr, pid int, cpu int, groupFd int, flags int) (fd int, err error) 1870 //sys PivotRoot(newroot string, putold string) (err error) = SYS_PIVOT_ROOT 1871 //sysnb Prlimit(pid int, resource int, newlimit *Rlimit, old *Rlimit) (err error) = SYS_PRLIMIT64 1872 //sys Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error) 1873 //sys Pselect(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timespec, sigmask *Sigset_t) (n int, err error) = SYS_PSELECT6 1874 //sys read(fd int, p []byte) (n int, err error) 1875 //sys Removexattr(path string, attr string) (err error) 1876 //sys Renameat2(olddirfd int, oldpath string, newdirfd int, newpath string, flags uint) (err error) 1877 //sys RequestKey(keyType string, description string, callback string, destRingid int) (id int, err error) 1878 //sys Setdomainname(p []byte) (err error) 1879 //sys Sethostname(p []byte) (err error) 1880 //sysnb Setpgid(pid int, pgid int) (err error) 1881 //sysnb Setsid() (pid int, err error) 1882 //sysnb Settimeofday(tv *Timeval) (err error) 1883 //sys Setns(fd int, nstype int) (err error) 1884 1885 // PrctlRetInt performs a prctl operation specified by option and further 1886 // optional arguments arg2 through arg5 depending on option. It returns a 1887 // non-negative integer that is returned by the prctl syscall. 1888 func PrctlRetInt(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (int, error) { 1889 ret, _, err := Syscall6(SYS_PRCTL, uintptr(option), uintptr(arg2), uintptr(arg3), uintptr(arg4), uintptr(arg5), 0) 1890 if err != 0 { 1891 return 0, err 1892 } 1893 return int(ret), nil 1894 } 1895 1896 func Setuid(uid int) (err error) { 1897 return syscall.Setuid(uid) 1898 } 1899 1900 func Setgid(gid int) (err error) { 1901 return syscall.Setgid(gid) 1902 } 1903 1904 func Setreuid(ruid, euid int) (err error) { 1905 return syscall.Setreuid(ruid, euid) 1906 } 1907 1908 func Setregid(rgid, egid int) (err error) { 1909 return syscall.Setregid(rgid, egid) 1910 } 1911 1912 func Setresuid(ruid, euid, suid int) (err error) { 1913 return syscall.Setresuid(ruid, euid, suid) 1914 } 1915 1916 func Setresgid(rgid, egid, sgid int) (err error) { 1917 return syscall.Setresgid(rgid, egid, sgid) 1918 } 1919 1920 // SetfsgidRetGid sets fsgid for current thread and returns previous fsgid set. 1921 // setfsgid(2) will return a non-nil error only if its caller lacks CAP_SETUID capability. 1922 // If the call fails due to other reasons, current fsgid will be returned. 1923 func SetfsgidRetGid(gid int) (int, error) { 1924 return setfsgid(gid) 1925 } 1926 1927 // SetfsuidRetUid sets fsuid for current thread and returns previous fsuid set. 1928 // setfsgid(2) will return a non-nil error only if its caller lacks CAP_SETUID capability 1929 // If the call fails due to other reasons, current fsuid will be returned. 1930 func SetfsuidRetUid(uid int) (int, error) { 1931 return setfsuid(uid) 1932 } 1933 1934 func Setfsgid(gid int) error { 1935 _, err := setfsgid(gid) 1936 return err 1937 } 1938 1939 func Setfsuid(uid int) error { 1940 _, err := setfsuid(uid) 1941 return err 1942 } 1943 1944 func Signalfd(fd int, sigmask *Sigset_t, flags int) (newfd int, err error) { 1945 return signalfd(fd, sigmask, _C__NSIG/8, flags) 1946 } 1947 1948 //sys Setpriority(which int, who int, prio int) (err error) 1949 //sys Setxattr(path string, attr string, data []byte, flags int) (err error) 1950 //sys signalfd(fd int, sigmask *Sigset_t, maskSize uintptr, flags int) (newfd int, err error) = SYS_SIGNALFD4 1951 //sys Statx(dirfd int, path string, flags int, mask int, stat *Statx_t) (err error) 1952 //sys Sync() 1953 //sys Syncfs(fd int) (err error) 1954 //sysnb Sysinfo(info *Sysinfo_t) (err error) 1955 //sys Tee(rfd int, wfd int, len int, flags int) (n int64, err error) 1956 //sysnb TimerfdCreate(clockid int, flags int) (fd int, err error) 1957 //sysnb TimerfdGettime(fd int, currValue *ItimerSpec) (err error) 1958 //sysnb TimerfdSettime(fd int, flags int, newValue *ItimerSpec, oldValue *ItimerSpec) (err error) 1959 //sysnb Tgkill(tgid int, tid int, sig syscall.Signal) (err error) 1960 //sysnb Times(tms *Tms) (ticks uintptr, err error) 1961 //sysnb Umask(mask int) (oldmask int) 1962 //sysnb Uname(buf *Utsname) (err error) 1963 //sys Unmount(target string, flags int) (err error) = SYS_UMOUNT2 1964 //sys Unshare(flags int) (err error) 1965 //sys write(fd int, p []byte) (n int, err error) 1966 //sys exitThread(code int) (err error) = SYS_EXIT 1967 //sys readlen(fd int, p *byte, np int) (n int, err error) = SYS_READ 1968 //sys writelen(fd int, p *byte, np int) (n int, err error) = SYS_WRITE 1969 //sys readv(fd int, iovs []Iovec) (n int, err error) = SYS_READV 1970 //sys writev(fd int, iovs []Iovec) (n int, err error) = SYS_WRITEV 1971 //sys preadv(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err error) = SYS_PREADV 1972 //sys pwritev(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr) (n int, err error) = SYS_PWRITEV 1973 //sys preadv2(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr, flags int) (n int, err error) = SYS_PREADV2 1974 //sys pwritev2(fd int, iovs []Iovec, offs_l uintptr, offs_h uintptr, flags int) (n int, err error) = SYS_PWRITEV2 1975 1976 func bytes2iovec(bs [][]byte) []Iovec { 1977 iovecs := make([]Iovec, len(bs)) 1978 for i, b := range bs { 1979 iovecs[i].SetLen(len(b)) 1980 if len(b) > 0 { 1981 iovecs[i].Base = &b[0] 1982 } else { 1983 iovecs[i].Base = (*byte)(unsafe.Pointer(&_zero)) 1984 } 1985 } 1986 return iovecs 1987 } 1988 1989 // offs2lohi splits offs into its lower and upper unsigned long. On 64-bit 1990 // systems, hi will always be 0. On 32-bit systems, offs will be split in half. 1991 // preadv/pwritev chose this calling convention so they don't need to add a 1992 // padding-register for alignment on ARM. 1993 func offs2lohi(offs int64) (lo, hi uintptr) { 1994 return uintptr(offs), uintptr(uint64(offs) >> SizeofLong) 1995 } 1996 1997 func Readv(fd int, iovs [][]byte) (n int, err error) { 1998 iovecs := bytes2iovec(iovs) 1999 n, err = readv(fd, iovecs) 2000 readvRacedetect(iovecs, n, err) 2001 return n, err 2002 } 2003 2004 func Preadv(fd int, iovs [][]byte, offset int64) (n int, err error) { 2005 iovecs := bytes2iovec(iovs) 2006 lo, hi := offs2lohi(offset) 2007 n, err = preadv(fd, iovecs, lo, hi) 2008 readvRacedetect(iovecs, n, err) 2009 return n, err 2010 } 2011 2012 func Preadv2(fd int, iovs [][]byte, offset int64, flags int) (n int, err error) { 2013 iovecs := bytes2iovec(iovs) 2014 lo, hi := offs2lohi(offset) 2015 n, err = preadv2(fd, iovecs, lo, hi, flags) 2016 readvRacedetect(iovecs, n, err) 2017 return n, err 2018 } 2019 2020 func readvRacedetect(iovecs []Iovec, n int, err error) { 2021 if !raceenabled { 2022 return 2023 } 2024 for i := 0; n > 0 && i < len(iovecs); i++ { 2025 m := int(iovecs[i].Len) 2026 if m > n { 2027 m = n 2028 } 2029 n -= m 2030 if m > 0 { 2031 raceWriteRange(unsafe.Pointer(iovecs[i].Base), m) 2032 } 2033 } 2034 if err == nil { 2035 raceAcquire(unsafe.Pointer(&ioSync)) 2036 } 2037 } 2038 2039 func Writev(fd int, iovs [][]byte) (n int, err error) { 2040 iovecs := bytes2iovec(iovs) 2041 if raceenabled { 2042 raceReleaseMerge(unsafe.Pointer(&ioSync)) 2043 } 2044 n, err = writev(fd, iovecs) 2045 writevRacedetect(iovecs, n) 2046 return n, err 2047 } 2048 2049 func Pwritev(fd int, iovs [][]byte, offset int64) (n int, err error) { 2050 iovecs := bytes2iovec(iovs) 2051 if raceenabled { 2052 raceReleaseMerge(unsafe.Pointer(&ioSync)) 2053 } 2054 lo, hi := offs2lohi(offset) 2055 n, err = pwritev(fd, iovecs, lo, hi) 2056 writevRacedetect(iovecs, n) 2057 return n, err 2058 } 2059 2060 func Pwritev2(fd int, iovs [][]byte, offset int64, flags int) (n int, err error) { 2061 iovecs := bytes2iovec(iovs) 2062 if raceenabled { 2063 raceReleaseMerge(unsafe.Pointer(&ioSync)) 2064 } 2065 lo, hi := offs2lohi(offset) 2066 n, err = pwritev2(fd, iovecs, lo, hi, flags) 2067 writevRacedetect(iovecs, n) 2068 return n, err 2069 } 2070 2071 func writevRacedetect(iovecs []Iovec, n int) { 2072 if !raceenabled { 2073 return 2074 } 2075 for i := 0; n > 0 && i < len(iovecs); i++ { 2076 m := int(iovecs[i].Len) 2077 if m > n { 2078 m = n 2079 } 2080 n -= m 2081 if m > 0 { 2082 raceReadRange(unsafe.Pointer(iovecs[i].Base), m) 2083 } 2084 } 2085 } 2086 2087 // mmap varies by architecture; see syscall_linux_*.go. 2088 //sys munmap(addr uintptr, length uintptr) (err error) 2089 2090 var mapper = &mmapper{ 2091 active: make(map[*byte][]byte), 2092 mmap: mmap, 2093 munmap: munmap, 2094 } 2095 2096 func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) { 2097 return mapper.Mmap(fd, offset, length, prot, flags) 2098 } 2099 2100 func Munmap(b []byte) (err error) { 2101 return mapper.Munmap(b) 2102 } 2103 2104 //sys Madvise(b []byte, advice int) (err error) 2105 //sys Mprotect(b []byte, prot int) (err error) 2106 //sys Mlock(b []byte) (err error) 2107 //sys Mlockall(flags int) (err error) 2108 //sys Msync(b []byte, flags int) (err error) 2109 //sys Munlock(b []byte) (err error) 2110 //sys Munlockall() (err error) 2111 2112 // Vmsplice splices user pages from a slice of Iovecs into a pipe specified by fd, 2113 // using the specified flags. 2114 func Vmsplice(fd int, iovs []Iovec, flags int) (int, error) { 2115 var p unsafe.Pointer 2116 if len(iovs) > 0 { 2117 p = unsafe.Pointer(&iovs[0]) 2118 } 2119 2120 n, _, errno := Syscall6(SYS_VMSPLICE, uintptr(fd), uintptr(p), uintptr(len(iovs)), uintptr(flags), 0, 0) 2121 if errno != 0 { 2122 return 0, syscall.Errno(errno) 2123 } 2124 2125 return int(n), nil 2126 } 2127 2128 func isGroupMember(gid int) bool { 2129 groups, err := Getgroups() 2130 if err != nil { 2131 return false 2132 } 2133 2134 for _, g := range groups { 2135 if g == gid { 2136 return true 2137 } 2138 } 2139 return false 2140 } 2141 2142 //sys faccessat(dirfd int, path string, mode uint32) (err error) 2143 //sys Faccessat2(dirfd int, path string, mode uint32, flags int) (err error) 2144 2145 func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) { 2146 if flags == 0 { 2147 return faccessat(dirfd, path, mode) 2148 } 2149 2150 if err := Faccessat2(dirfd, path, mode, flags); err != ENOSYS && err != EPERM { 2151 return err 2152 } 2153 2154 // The Linux kernel faccessat system call does not take any flags. 2155 // The glibc faccessat implements the flags itself; see 2156 // https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/unix/sysv/linux/faccessat.c;hb=HEAD 2157 // Because people naturally expect syscall.Faccessat to act 2158 // like C faccessat, we do the same. 2159 2160 if flags & ^(AT_SYMLINK_NOFOLLOW|AT_EACCESS) != 0 { 2161 return EINVAL 2162 } 2163 2164 var st Stat_t 2165 if err := Fstatat(dirfd, path, &st, flags&AT_SYMLINK_NOFOLLOW); err != nil { 2166 return err 2167 } 2168 2169 mode &= 7 2170 if mode == 0 { 2171 return nil 2172 } 2173 2174 var uid int 2175 if flags&AT_EACCESS != 0 { 2176 uid = Geteuid() 2177 } else { 2178 uid = Getuid() 2179 } 2180 2181 if uid == 0 { 2182 if mode&1 == 0 { 2183 // Root can read and write any file. 2184 return nil 2185 } 2186 if st.Mode&0111 != 0 { 2187 // Root can execute any file that anybody can execute. 2188 return nil 2189 } 2190 return EACCES 2191 } 2192 2193 var fmode uint32 2194 if uint32(uid) == st.Uid { 2195 fmode = (st.Mode >> 6) & 7 2196 } else { 2197 var gid int 2198 if flags&AT_EACCESS != 0 { 2199 gid = Getegid() 2200 } else { 2201 gid = Getgid() 2202 } 2203 2204 if uint32(gid) == st.Gid || isGroupMember(int(st.Gid)) { 2205 fmode = (st.Mode >> 3) & 7 2206 } else { 2207 fmode = st.Mode & 7 2208 } 2209 } 2210 2211 if fmode&mode == mode { 2212 return nil 2213 } 2214 2215 return EACCES 2216 } 2217 2218 //sys nameToHandleAt(dirFD int, pathname string, fh *fileHandle, mountID *_C_int, flags int) (err error) = SYS_NAME_TO_HANDLE_AT 2219 //sys openByHandleAt(mountFD int, fh *fileHandle, flags int) (fd int, err error) = SYS_OPEN_BY_HANDLE_AT 2220 2221 // fileHandle is the argument to nameToHandleAt and openByHandleAt. We 2222 // originally tried to generate it via unix/linux/types.go with "type 2223 // fileHandle C.struct_file_handle" but that generated empty structs 2224 // for mips64 and mips64le. Instead, hard code it for now (it's the 2225 // same everywhere else) until the mips64 generator issue is fixed. 2226 type fileHandle struct { 2227 Bytes uint32 2228 Type int32 2229 } 2230 2231 // FileHandle represents the C struct file_handle used by 2232 // name_to_handle_at (see NameToHandleAt) and open_by_handle_at (see 2233 // OpenByHandleAt). 2234 type FileHandle struct { 2235 *fileHandle 2236 } 2237 2238 // NewFileHandle constructs a FileHandle. 2239 func NewFileHandle(handleType int32, handle []byte) FileHandle { 2240 const hdrSize = unsafe.Sizeof(fileHandle{}) 2241 buf := make([]byte, hdrSize+uintptr(len(handle))) 2242 copy(buf[hdrSize:], handle) 2243 fh := (*fileHandle)(unsafe.Pointer(&buf[0])) 2244 fh.Type = handleType 2245 fh.Bytes = uint32(len(handle)) 2246 return FileHandle{fh} 2247 } 2248 2249 func (fh *FileHandle) Size() int { return int(fh.fileHandle.Bytes) } 2250 func (fh *FileHandle) Type() int32 { return fh.fileHandle.Type } 2251 func (fh *FileHandle) Bytes() []byte { 2252 n := fh.Size() 2253 if n == 0 { 2254 return nil 2255 } 2256 return unsafe.Slice((*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(&fh.fileHandle.Type))+4)), n) 2257 } 2258 2259 // NameToHandleAt wraps the name_to_handle_at system call; it obtains 2260 // a handle for a path name. 2261 func NameToHandleAt(dirfd int, path string, flags int) (handle FileHandle, mountID int, err error) { 2262 var mid _C_int 2263 // Try first with a small buffer, assuming the handle will 2264 // only be 32 bytes. 2265 size := uint32(32 + unsafe.Sizeof(fileHandle{})) 2266 didResize := false 2267 for { 2268 buf := make([]byte, size) 2269 fh := (*fileHandle)(unsafe.Pointer(&buf[0])) 2270 fh.Bytes = size - uint32(unsafe.Sizeof(fileHandle{})) 2271 err = nameToHandleAt(dirfd, path, fh, &mid, flags) 2272 if err == EOVERFLOW { 2273 if didResize { 2274 // We shouldn't need to resize more than once 2275 return 2276 } 2277 didResize = true 2278 size = fh.Bytes + uint32(unsafe.Sizeof(fileHandle{})) 2279 continue 2280 } 2281 if err != nil { 2282 return 2283 } 2284 return FileHandle{fh}, int(mid), nil 2285 } 2286 } 2287 2288 // OpenByHandleAt wraps the open_by_handle_at system call; it opens a 2289 // file via a handle as previously returned by NameToHandleAt. 2290 func OpenByHandleAt(mountFD int, handle FileHandle, flags int) (fd int, err error) { 2291 return openByHandleAt(mountFD, handle.fileHandle, flags) 2292 } 2293 2294 // Klogset wraps the sys_syslog system call; it sets console_loglevel to 2295 // the value specified by arg and passes a dummy pointer to bufp. 2296 func Klogset(typ int, arg int) (err error) { 2297 var p unsafe.Pointer 2298 _, _, errno := Syscall(SYS_SYSLOG, uintptr(typ), uintptr(p), uintptr(arg)) 2299 if errno != 0 { 2300 return errnoErr(errno) 2301 } 2302 return nil 2303 } 2304 2305 // RemoteIovec is Iovec with the pointer replaced with an integer. 2306 // It is used for ProcessVMReadv and ProcessVMWritev, where the pointer 2307 // refers to a location in a different process' address space, which 2308 // would confuse the Go garbage collector. 2309 type RemoteIovec struct { 2310 Base uintptr 2311 Len int 2312 } 2313 2314 //sys ProcessVMReadv(pid int, localIov []Iovec, remoteIov []RemoteIovec, flags uint) (n int, err error) = SYS_PROCESS_VM_READV 2315 //sys ProcessVMWritev(pid int, localIov []Iovec, remoteIov []RemoteIovec, flags uint) (n int, err error) = SYS_PROCESS_VM_WRITEV 2316 2317 //sys PidfdOpen(pid int, flags int) (fd int, err error) = SYS_PIDFD_OPEN 2318 //sys PidfdGetfd(pidfd int, targetfd int, flags int) (fd int, err error) = SYS_PIDFD_GETFD 2319 //sys PidfdSendSignal(pidfd int, sig Signal, info *Siginfo, flags int) (err error) = SYS_PIDFD_SEND_SIGNAL 2320 2321 //sys shmat(id int, addr uintptr, flag int) (ret uintptr, err error) 2322 //sys shmctl(id int, cmd int, buf *SysvShmDesc) (result int, err error) 2323 //sys shmdt(addr uintptr) (err error) 2324 //sys shmget(key int, size int, flag int) (id int, err error) 2325 2326 //sys getitimer(which int, currValue *Itimerval) (err error) 2327 //sys setitimer(which int, newValue *Itimerval, oldValue *Itimerval) (err error) 2328 2329 // MakeItimerval creates an Itimerval from interval and value durations. 2330 func MakeItimerval(interval, value time.Duration) Itimerval { 2331 return Itimerval{ 2332 Interval: NsecToTimeval(interval.Nanoseconds()), 2333 Value: NsecToTimeval(value.Nanoseconds()), 2334 } 2335 } 2336 2337 // A value which may be passed to the which parameter for Getitimer and 2338 // Setitimer. 2339 type ItimerWhich int 2340 2341 // Possible which values for Getitimer and Setitimer. 2342 const ( 2343 ItimerReal ItimerWhich = ITIMER_REAL 2344 ItimerVirtual ItimerWhich = ITIMER_VIRTUAL 2345 ItimerProf ItimerWhich = ITIMER_PROF 2346 ) 2347 2348 // Getitimer wraps getitimer(2) to return the current value of the timer 2349 // specified by which. 2350 func Getitimer(which ItimerWhich) (Itimerval, error) { 2351 var it Itimerval 2352 if err := getitimer(int(which), &it); err != nil { 2353 return Itimerval{}, err 2354 } 2355 2356 return it, nil 2357 } 2358 2359 // Setitimer wraps setitimer(2) to arm or disarm the timer specified by which. 2360 // It returns the previous value of the timer. 2361 // 2362 // If the Itimerval argument is the zero value, the timer will be disarmed. 2363 func Setitimer(which ItimerWhich, it Itimerval) (Itimerval, error) { 2364 var prev Itimerval 2365 if err := setitimer(int(which), &it, &prev); err != nil { 2366 return Itimerval{}, err 2367 } 2368 2369 return prev, nil 2370 } 2371 2372 //sysnb rtSigprocmask(how int, set *Sigset_t, oldset *Sigset_t, sigsetsize uintptr) (err error) = SYS_RT_SIGPROCMASK 2373 2374 func PthreadSigmask(how int, set, oldset *Sigset_t) error { 2375 if oldset != nil { 2376 // Explicitly clear in case Sigset_t is larger than _C__NSIG. 2377 *oldset = Sigset_t{} 2378 } 2379 return rtSigprocmask(how, set, oldset, _C__NSIG/8) 2380 } 2381 2382 /* 2383 * Unimplemented 2384 */ 2385 // AfsSyscall 2386 // ArchPrctl 2387 // Brk 2388 // ClockNanosleep 2389 // ClockSettime 2390 // Clone 2391 // EpollCtlOld 2392 // EpollPwait 2393 // EpollWaitOld 2394 // Execve 2395 // Fork 2396 // Futex 2397 // GetKernelSyms 2398 // GetMempolicy 2399 // GetRobustList 2400 // GetThreadArea 2401 // Getpmsg 2402 // IoCancel 2403 // IoDestroy 2404 // IoGetevents 2405 // IoSetup 2406 // IoSubmit 2407 // IoprioGet 2408 // IoprioSet 2409 // KexecLoad 2410 // LookupDcookie 2411 // Mbind 2412 // MigratePages 2413 // Mincore 2414 // ModifyLdt 2415 // Mount 2416 // MovePages 2417 // MqGetsetattr 2418 // MqNotify 2419 // MqOpen 2420 // MqTimedreceive 2421 // MqTimedsend 2422 // MqUnlink 2423 // Mremap 2424 // Msgctl 2425 // Msgget 2426 // Msgrcv 2427 // Msgsnd 2428 // Nfsservctl 2429 // Personality 2430 // Pselect6 2431 // Ptrace 2432 // Putpmsg 2433 // Quotactl 2434 // Readahead 2435 // Readv 2436 // RemapFilePages 2437 // RestartSyscall 2438 // RtSigaction 2439 // RtSigpending 2440 // RtSigqueueinfo 2441 // RtSigreturn 2442 // RtSigsuspend 2443 // RtSigtimedwait 2444 // SchedGetPriorityMax 2445 // SchedGetPriorityMin 2446 // SchedGetparam 2447 // SchedGetscheduler 2448 // SchedRrGetInterval 2449 // SchedSetparam 2450 // SchedYield 2451 // Security 2452 // Semctl 2453 // Semget 2454 // Semop 2455 // Semtimedop 2456 // SetMempolicy 2457 // SetRobustList 2458 // SetThreadArea 2459 // SetTidAddress 2460 // Sigaltstack 2461 // Swapoff 2462 // Swapon 2463 // Sysfs 2464 // TimerCreate 2465 // TimerDelete 2466 // TimerGetoverrun 2467 // TimerGettime 2468 // TimerSettime 2469 // Tkill (obsolete) 2470 // Tuxcall 2471 // Umount2 2472 // Uselib 2473 // Utimensat 2474 // Vfork 2475 // Vhangup 2476 // Vserver 2477 // _Sysctl