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//go:build darwin || dragonfly || freebsd || netbsd || openbsd 6// +build darwin dragonfly freebsd netbsd openbsd 7 8// BSD system call wrappers shared by *BSD based systems 9// including OS X (Darwin) and FreeBSD. Like the other 10// syscall_*.go files it is compiled as Go code but also 11// used as input to mksyscall which parses the //sys 12// lines and generates system call stubs. 13 14package unix 15 16import ( 17 "runtime" 18 "syscall" 19 "unsafe" 20) 21 22const ImplementsGetwd = true 23 24func Getwd() (string, error) { 25 var buf [PathMax]byte 26 _, err := Getcwd(buf[0:]) 27 if err != nil { 28 return "", err 29 } 30 n := clen(buf[:]) 31 if n < 1 { 32 return "", EINVAL 33 } 34 return string(buf[:n]), nil 35} 36 37/* 38 * Wrapped 39 */ 40 41//sysnb getgroups(ngid int, gid *_Gid_t) (n int, err error) 42//sysnb setgroups(ngid int, gid *_Gid_t) (err error) 43 44func Getgroups() (gids []int, err error) { 45 n, err := getgroups(0, nil) 46 if err != nil { 47 return nil, err 48 } 49 if n == 0 { 50 return nil, nil 51 } 52 53 // Sanity check group count. Max is 16 on BSD. 54 if n < 0 || n > 1000 { 55 return nil, EINVAL 56 } 57 58 a := make([]_Gid_t, n) 59 n, err = getgroups(n, &a[0]) 60 if err != nil { 61 return nil, err 62 } 63 gids = make([]int, n) 64 for i, v := range a[0:n] { 65 gids[i] = int(v) 66 } 67 return 68} 69 70func Setgroups(gids []int) (err error) { 71 if len(gids) == 0 { 72 return setgroups(0, nil) 73 } 74 75 a := make([]_Gid_t, len(gids)) 76 for i, v := range gids { 77 a[i] = _Gid_t(v) 78 } 79 return setgroups(len(a), &a[0]) 80} 81 82// Wait status is 7 bits at bottom, either 0 (exited), 83// 0x7F (stopped), or a signal number that caused an exit. 84// The 0x80 bit is whether there was a core dump. 85// An extra number (exit code, signal causing a stop) 86// is in the high bits. 87 88type WaitStatus uint32 89 90const ( 91 mask = 0x7F 92 core = 0x80 93 shift = 8 94 95 exited = 0 96 killed = 9 97 stopped = 0x7F 98) 99 100func (w WaitStatus) Exited() bool { return w&mask == exited } 101 102func (w WaitStatus) ExitStatus() int { 103 if w&mask != exited { 104 return -1 105 } 106 return int(w >> shift) 107} 108 109func (w WaitStatus) Signaled() bool { return w&mask != stopped && w&mask != 0 } 110 111func (w WaitStatus) Signal() syscall.Signal { 112 sig := syscall.Signal(w & mask) 113 if sig == stopped || sig == 0 { 114 return -1 115 } 116 return sig 117} 118 119func (w WaitStatus) CoreDump() bool { return w.Signaled() && w&core != 0 } 120 121func (w WaitStatus) Stopped() bool { return w&mask == stopped && syscall.Signal(w>>shift) != SIGSTOP } 122 123func (w WaitStatus) Killed() bool { return w&mask == killed && syscall.Signal(w>>shift) != SIGKILL } 124 125func (w WaitStatus) Continued() bool { return w&mask == stopped && syscall.Signal(w>>shift) == SIGSTOP } 126 127func (w WaitStatus) StopSignal() syscall.Signal { 128 if !w.Stopped() { 129 return -1 130 } 131 return syscall.Signal(w>>shift) & 0xFF 132} 133 134func (w WaitStatus) TrapCause() int { return -1 } 135 136//sys wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) 137 138func Wait4(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error) { 139 var status _C_int 140 wpid, err = wait4(pid, &status, options, rusage) 141 if wstatus != nil { 142 *wstatus = WaitStatus(status) 143 } 144 return 145} 146 147//sys accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) 148//sys bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) 149//sys connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) 150//sysnb socket(domain int, typ int, proto int) (fd int, err error) 151//sys getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) 152//sys setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) 153//sysnb getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) 154//sysnb getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) 155//sys Shutdown(s int, how int) (err error) 156 157func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) { 158 if sa.Port < 0 || sa.Port > 0xFFFF { 159 return nil, 0, EINVAL 160 } 161 sa.raw.Len = SizeofSockaddrInet4 162 sa.raw.Family = AF_INET 163 p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) 164 p[0] = byte(sa.Port >> 8) 165 p[1] = byte(sa.Port) 166 for i := 0; i < len(sa.Addr); i++ { 167 sa.raw.Addr[i] = sa.Addr[i] 168 } 169 return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil 170} 171 172func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) { 173 if sa.Port < 0 || sa.Port > 0xFFFF { 174 return nil, 0, EINVAL 175 } 176 sa.raw.Len = SizeofSockaddrInet6 177 sa.raw.Family = AF_INET6 178 p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) 179 p[0] = byte(sa.Port >> 8) 180 p[1] = byte(sa.Port) 181 sa.raw.Scope_id = sa.ZoneId 182 for i := 0; i < len(sa.Addr); i++ { 183 sa.raw.Addr[i] = sa.Addr[i] 184 } 185 return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil 186} 187 188func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) { 189 name := sa.Name 190 n := len(name) 191 if n >= len(sa.raw.Path) || n == 0 { 192 return nil, 0, EINVAL 193 } 194 sa.raw.Len = byte(3 + n) // 2 for Family, Len; 1 for NUL 195 sa.raw.Family = AF_UNIX 196 for i := 0; i < n; i++ { 197 sa.raw.Path[i] = int8(name[i]) 198 } 199 return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil 200} 201 202func (sa *SockaddrDatalink) sockaddr() (unsafe.Pointer, _Socklen, error) { 203 if sa.Index == 0 { 204 return nil, 0, EINVAL 205 } 206 sa.raw.Len = sa.Len 207 sa.raw.Family = AF_LINK 208 sa.raw.Index = sa.Index 209 sa.raw.Type = sa.Type 210 sa.raw.Nlen = sa.Nlen 211 sa.raw.Alen = sa.Alen 212 sa.raw.Slen = sa.Slen 213 for i := 0; i < len(sa.raw.Data); i++ { 214 sa.raw.Data[i] = sa.Data[i] 215 } 216 return unsafe.Pointer(&sa.raw), SizeofSockaddrDatalink, nil 217} 218 219func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) { 220 switch rsa.Addr.Family { 221 case AF_LINK: 222 pp := (*RawSockaddrDatalink)(unsafe.Pointer(rsa)) 223 sa := new(SockaddrDatalink) 224 sa.Len = pp.Len 225 sa.Family = pp.Family 226 sa.Index = pp.Index 227 sa.Type = pp.Type 228 sa.Nlen = pp.Nlen 229 sa.Alen = pp.Alen 230 sa.Slen = pp.Slen 231 for i := 0; i < len(sa.Data); i++ { 232 sa.Data[i] = pp.Data[i] 233 } 234 return sa, nil 235 236 case AF_UNIX: 237 pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa)) 238 if pp.Len < 2 || pp.Len > SizeofSockaddrUnix { 239 return nil, EINVAL 240 } 241 sa := new(SockaddrUnix) 242 243 // Some BSDs include the trailing NUL in the length, whereas 244 // others do not. Work around this by subtracting the leading 245 // family and len. The path is then scanned to see if a NUL 246 // terminator still exists within the length. 247 n := int(pp.Len) - 2 // subtract leading Family, Len 248 for i := 0; i < n; i++ { 249 if pp.Path[i] == 0 { 250 // found early NUL; assume Len included the NUL 251 // or was overestimating. 252 n = i 253 break 254 } 255 } 256 bytes := (*[len(pp.Path)]byte)(unsafe.Pointer(&pp.Path[0]))[0:n] 257 sa.Name = string(bytes) 258 return sa, nil 259 260 case AF_INET: 261 pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa)) 262 sa := new(SockaddrInet4) 263 p := (*[2]byte)(unsafe.Pointer(&pp.Port)) 264 sa.Port = int(p[0])<<8 + int(p[1]) 265 for i := 0; i < len(sa.Addr); i++ { 266 sa.Addr[i] = pp.Addr[i] 267 } 268 return sa, nil 269 270 case AF_INET6: 271 pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa)) 272 sa := new(SockaddrInet6) 273 p := (*[2]byte)(unsafe.Pointer(&pp.Port)) 274 sa.Port = int(p[0])<<8 + int(p[1]) 275 sa.ZoneId = pp.Scope_id 276 for i := 0; i < len(sa.Addr); i++ { 277 sa.Addr[i] = pp.Addr[i] 278 } 279 return sa, nil 280 } 281 return anyToSockaddrGOOS(fd, rsa) 282} 283 284func Accept(fd int) (nfd int, sa Sockaddr, err error) { 285 var rsa RawSockaddrAny 286 var len _Socklen = SizeofSockaddrAny 287 nfd, err = accept(fd, &rsa, &len) 288 if err != nil { 289 return 290 } 291 if (runtime.GOOS == "darwin" || runtime.GOOS == "ios") && len == 0 { 292 // Accepted socket has no address. 293 // This is likely due to a bug in xnu kernels, 294 // where instead of ECONNABORTED error socket 295 // is accepted, but has no address. 296 Close(nfd) 297 return 0, nil, ECONNABORTED 298 } 299 sa, err = anyToSockaddr(fd, &rsa) 300 if err != nil { 301 Close(nfd) 302 nfd = 0 303 } 304 return 305} 306 307func Getsockname(fd int) (sa Sockaddr, err error) { 308 var rsa RawSockaddrAny 309 var len _Socklen = SizeofSockaddrAny 310 if err = getsockname(fd, &rsa, &len); err != nil { 311 return 312 } 313 // TODO(jsing): DragonFly has a "bug" (see issue 3349), which should be 314 // reported upstream. 315 if runtime.GOOS == "dragonfly" && rsa.Addr.Family == AF_UNSPEC && rsa.Addr.Len == 0 { 316 rsa.Addr.Family = AF_UNIX 317 rsa.Addr.Len = SizeofSockaddrUnix 318 } 319 return anyToSockaddr(fd, &rsa) 320} 321 322//sysnb socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) 323 324// GetsockoptString returns the string value of the socket option opt for the 325// socket associated with fd at the given socket level. 326func GetsockoptString(fd, level, opt int) (string, error) { 327 buf := make([]byte, 256) 328 vallen := _Socklen(len(buf)) 329 err := getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen) 330 if err != nil { 331 return "", err 332 } 333 return string(buf[:vallen-1]), nil 334} 335 336//sys recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) 337//sys sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) 338//sys recvmsg(s int, msg *Msghdr, flags int) (n int, err error) 339 340func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) { 341 var msg Msghdr 342 var rsa RawSockaddrAny 343 msg.Name = (*byte)(unsafe.Pointer(&rsa)) 344 msg.Namelen = uint32(SizeofSockaddrAny) 345 var iov Iovec 346 if len(p) > 0 { 347 iov.Base = (*byte)(unsafe.Pointer(&p[0])) 348 iov.SetLen(len(p)) 349 } 350 var dummy byte 351 if len(oob) > 0 { 352 // receive at least one normal byte 353 if len(p) == 0 { 354 iov.Base = &dummy 355 iov.SetLen(1) 356 } 357 msg.Control = (*byte)(unsafe.Pointer(&oob[0])) 358 msg.SetControllen(len(oob)) 359 } 360 msg.Iov = &iov 361 msg.Iovlen = 1 362 if n, err = recvmsg(fd, &msg, flags); err != nil { 363 return 364 } 365 oobn = int(msg.Controllen) 366 recvflags = int(msg.Flags) 367 // source address is only specified if the socket is unconnected 368 if rsa.Addr.Family != AF_UNSPEC { 369 from, err = anyToSockaddr(fd, &rsa) 370 } 371 return 372} 373 374//sys sendmsg(s int, msg *Msghdr, flags int) (n int, err error) 375 376func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) { 377 _, err = SendmsgN(fd, p, oob, to, flags) 378 return 379} 380 381func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) { 382 var ptr unsafe.Pointer 383 var salen _Socklen 384 if to != nil { 385 ptr, salen, err = to.sockaddr() 386 if err != nil { 387 return 0, err 388 } 389 } 390 var msg Msghdr 391 msg.Name = (*byte)(unsafe.Pointer(ptr)) 392 msg.Namelen = uint32(salen) 393 var iov Iovec 394 if len(p) > 0 { 395 iov.Base = (*byte)(unsafe.Pointer(&p[0])) 396 iov.SetLen(len(p)) 397 } 398 var dummy byte 399 if len(oob) > 0 { 400 // send at least one normal byte 401 if len(p) == 0 { 402 iov.Base = &dummy 403 iov.SetLen(1) 404 } 405 msg.Control = (*byte)(unsafe.Pointer(&oob[0])) 406 msg.SetControllen(len(oob)) 407 } 408 msg.Iov = &iov 409 msg.Iovlen = 1 410 if n, err = sendmsg(fd, &msg, flags); err != nil { 411 return 0, err 412 } 413 if len(oob) > 0 && len(p) == 0 { 414 n = 0 415 } 416 return n, nil 417} 418 419//sys kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) 420 421func Kevent(kq int, changes, events []Kevent_t, timeout *Timespec) (n int, err error) { 422 var change, event unsafe.Pointer 423 if len(changes) > 0 { 424 change = unsafe.Pointer(&changes[0]) 425 } 426 if len(events) > 0 { 427 event = unsafe.Pointer(&events[0]) 428 } 429 return kevent(kq, change, len(changes), event, len(events), timeout) 430} 431 432// sysctlmib translates name to mib number and appends any additional args. 433func sysctlmib(name string, args ...int) ([]_C_int, error) { 434 // Translate name to mib number. 435 mib, err := nametomib(name) 436 if err != nil { 437 return nil, err 438 } 439 440 for _, a := range args { 441 mib = append(mib, _C_int(a)) 442 } 443 444 return mib, nil 445} 446 447func Sysctl(name string) (string, error) { 448 return SysctlArgs(name) 449} 450 451func SysctlArgs(name string, args ...int) (string, error) { 452 buf, err := SysctlRaw(name, args...) 453 if err != nil { 454 return "", err 455 } 456 n := len(buf) 457 458 // Throw away terminating NUL. 459 if n > 0 && buf[n-1] == '\x00' { 460 n-- 461 } 462 return string(buf[0:n]), nil 463} 464 465func SysctlUint32(name string) (uint32, error) { 466 return SysctlUint32Args(name) 467} 468 469func SysctlUint32Args(name string, args ...int) (uint32, error) { 470 mib, err := sysctlmib(name, args...) 471 if err != nil { 472 return 0, err 473 } 474 475 n := uintptr(4) 476 buf := make([]byte, 4) 477 if err := sysctl(mib, &buf[0], &n, nil, 0); err != nil { 478 return 0, err 479 } 480 if n != 4 { 481 return 0, EIO 482 } 483 return *(*uint32)(unsafe.Pointer(&buf[0])), nil 484} 485 486func SysctlUint64(name string, args ...int) (uint64, error) { 487 mib, err := sysctlmib(name, args...) 488 if err != nil { 489 return 0, err 490 } 491 492 n := uintptr(8) 493 buf := make([]byte, 8) 494 if err := sysctl(mib, &buf[0], &n, nil, 0); err != nil { 495 return 0, err 496 } 497 if n != 8 { 498 return 0, EIO 499 } 500 return *(*uint64)(unsafe.Pointer(&buf[0])), nil 501} 502 503func SysctlRaw(name string, args ...int) ([]byte, error) { 504 mib, err := sysctlmib(name, args...) 505 if err != nil { 506 return nil, err 507 } 508 509 // Find size. 510 n := uintptr(0) 511 if err := sysctl(mib, nil, &n, nil, 0); err != nil { 512 return nil, err 513 } 514 if n == 0 { 515 return nil, nil 516 } 517 518 // Read into buffer of that size. 519 buf := make([]byte, n) 520 if err := sysctl(mib, &buf[0], &n, nil, 0); err != nil { 521 return nil, err 522 } 523 524 // The actual call may return less than the original reported required 525 // size so ensure we deal with that. 526 return buf[:n], nil 527} 528 529func SysctlClockinfo(name string) (*Clockinfo, error) { 530 mib, err := sysctlmib(name) 531 if err != nil { 532 return nil, err 533 } 534 535 n := uintptr(SizeofClockinfo) 536 var ci Clockinfo 537 if err := sysctl(mib, (*byte)(unsafe.Pointer(&ci)), &n, nil, 0); err != nil { 538 return nil, err 539 } 540 if n != SizeofClockinfo { 541 return nil, EIO 542 } 543 return &ci, nil 544} 545 546func SysctlTimeval(name string) (*Timeval, error) { 547 mib, err := sysctlmib(name) 548 if err != nil { 549 return nil, err 550 } 551 552 var tv Timeval 553 n := uintptr(unsafe.Sizeof(tv)) 554 if err := sysctl(mib, (*byte)(unsafe.Pointer(&tv)), &n, nil, 0); err != nil { 555 return nil, err 556 } 557 if n != unsafe.Sizeof(tv) { 558 return nil, EIO 559 } 560 return &tv, nil 561} 562 563//sys utimes(path string, timeval *[2]Timeval) (err error) 564 565func Utimes(path string, tv []Timeval) error { 566 if tv == nil { 567 return utimes(path, nil) 568 } 569 if len(tv) != 2 { 570 return EINVAL 571 } 572 return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) 573} 574 575func UtimesNano(path string, ts []Timespec) error { 576 if ts == nil { 577 err := utimensat(AT_FDCWD, path, nil, 0) 578 if err != ENOSYS { 579 return err 580 } 581 return utimes(path, nil) 582 } 583 if len(ts) != 2 { 584 return EINVAL 585 } 586 // Darwin setattrlist can set nanosecond timestamps 587 err := setattrlistTimes(path, ts, 0) 588 if err != ENOSYS { 589 return err 590 } 591 err = utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0) 592 if err != ENOSYS { 593 return err 594 } 595 // Not as efficient as it could be because Timespec and 596 // Timeval have different types in the different OSes 597 tv := [2]Timeval{ 598 NsecToTimeval(TimespecToNsec(ts[0])), 599 NsecToTimeval(TimespecToNsec(ts[1])), 600 } 601 return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) 602} 603 604func UtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) error { 605 if ts == nil { 606 return utimensat(dirfd, path, nil, flags) 607 } 608 if len(ts) != 2 { 609 return EINVAL 610 } 611 err := setattrlistTimes(path, ts, flags) 612 if err != ENOSYS { 613 return err 614 } 615 return utimensat(dirfd, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), flags) 616} 617 618//sys futimes(fd int, timeval *[2]Timeval) (err error) 619 620func Futimes(fd int, tv []Timeval) error { 621 if tv == nil { 622 return futimes(fd, nil) 623 } 624 if len(tv) != 2 { 625 return EINVAL 626 } 627 return futimes(fd, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) 628} 629 630//sys poll(fds *PollFd, nfds int, timeout int) (n int, err error) 631 632func Poll(fds []PollFd, timeout int) (n int, err error) { 633 if len(fds) == 0 { 634 return poll(nil, 0, timeout) 635 } 636 return poll(&fds[0], len(fds), timeout) 637} 638 639// TODO: wrap 640// Acct(name nil-string) (err error) 641// Gethostuuid(uuid *byte, timeout *Timespec) (err error) 642// Ptrace(req int, pid int, addr uintptr, data int) (ret uintptr, err error) 643 644var mapper = &mmapper{ 645 active: make(map[*byte][]byte), 646 mmap: mmap, 647 munmap: munmap, 648} 649 650func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) { 651 return mapper.Mmap(fd, offset, length, prot, flags) 652} 653 654func Munmap(b []byte) (err error) { 655 return mapper.Munmap(b) 656} 657 658//sys Madvise(b []byte, behav int) (err error) 659//sys Mlock(b []byte) (err error) 660//sys Mlockall(flags int) (err error) 661//sys Mprotect(b []byte, prot int) (err error) 662//sys Msync(b []byte, flags int) (err error) 663//sys Munlock(b []byte) (err error) 664//sys Munlockall() (err error) 665