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