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