syscall_bsd.go (15664B)
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 14 package unix 15 16 import ( 17 "runtime" 18 "syscall" 19 "unsafe" 20 ) 21 22 const ImplementsGetwd = true 23 24 func 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 44 func 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 70 func 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 88 type WaitStatus uint32 89 90 const ( 91 mask = 0x7F 92 core = 0x80 93 shift = 8 94 95 exited = 0 96 killed = 9 97 stopped = 0x7F 98 ) 99 100 func (w WaitStatus) Exited() bool { return w&mask == exited } 101 102 func (w WaitStatus) ExitStatus() int { 103 if w&mask != exited { 104 return -1 105 } 106 return int(w >> shift) 107 } 108 109 func (w WaitStatus) Signaled() bool { return w&mask != stopped && w&mask != 0 } 110 111 func (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 119 func (w WaitStatus) CoreDump() bool { return w.Signaled() && w&core != 0 } 120 121 func (w WaitStatus) Stopped() bool { return w&mask == stopped && syscall.Signal(w>>shift) != SIGSTOP } 122 123 func (w WaitStatus) Killed() bool { return w&mask == killed && syscall.Signal(w>>shift) != SIGKILL } 124 125 func (w WaitStatus) Continued() bool { return w&mask == stopped && syscall.Signal(w>>shift) == SIGSTOP } 126 127 func (w WaitStatus) StopSignal() syscall.Signal { 128 if !w.Stopped() { 129 return -1 130 } 131 return syscall.Signal(w>>shift) & 0xFF 132 } 133 134 func (w WaitStatus) TrapCause() int { return -1 } 135 136 //sys wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) 137 138 func 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 157 func (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 sa.raw.Addr = sa.Addr 167 return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil 168 } 169 170 func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) { 171 if sa.Port < 0 || sa.Port > 0xFFFF { 172 return nil, 0, EINVAL 173 } 174 sa.raw.Len = SizeofSockaddrInet6 175 sa.raw.Family = AF_INET6 176 p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) 177 p[0] = byte(sa.Port >> 8) 178 p[1] = byte(sa.Port) 179 sa.raw.Scope_id = sa.ZoneId 180 sa.raw.Addr = sa.Addr 181 return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil 182 } 183 184 func (sa *SockaddrUnix) sockaddr() (unsafe.Pointer, _Socklen, error) { 185 name := sa.Name 186 n := len(name) 187 if n >= len(sa.raw.Path) || n == 0 { 188 return nil, 0, EINVAL 189 } 190 sa.raw.Len = byte(3 + n) // 2 for Family, Len; 1 for NUL 191 sa.raw.Family = AF_UNIX 192 for i := 0; i < n; i++ { 193 sa.raw.Path[i] = int8(name[i]) 194 } 195 return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil 196 } 197 198 func (sa *SockaddrDatalink) sockaddr() (unsafe.Pointer, _Socklen, error) { 199 if sa.Index == 0 { 200 return nil, 0, EINVAL 201 } 202 sa.raw.Len = sa.Len 203 sa.raw.Family = AF_LINK 204 sa.raw.Index = sa.Index 205 sa.raw.Type = sa.Type 206 sa.raw.Nlen = sa.Nlen 207 sa.raw.Alen = sa.Alen 208 sa.raw.Slen = sa.Slen 209 sa.raw.Data = sa.Data 210 return unsafe.Pointer(&sa.raw), SizeofSockaddrDatalink, nil 211 } 212 213 func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) { 214 switch rsa.Addr.Family { 215 case AF_LINK: 216 pp := (*RawSockaddrDatalink)(unsafe.Pointer(rsa)) 217 sa := new(SockaddrDatalink) 218 sa.Len = pp.Len 219 sa.Family = pp.Family 220 sa.Index = pp.Index 221 sa.Type = pp.Type 222 sa.Nlen = pp.Nlen 223 sa.Alen = pp.Alen 224 sa.Slen = pp.Slen 225 sa.Data = pp.Data 226 return sa, nil 227 228 case AF_UNIX: 229 pp := (*RawSockaddrUnix)(unsafe.Pointer(rsa)) 230 if pp.Len < 2 || pp.Len > SizeofSockaddrUnix { 231 return nil, EINVAL 232 } 233 sa := new(SockaddrUnix) 234 235 // Some BSDs include the trailing NUL in the length, whereas 236 // others do not. Work around this by subtracting the leading 237 // family and len. The path is then scanned to see if a NUL 238 // terminator still exists within the length. 239 n := int(pp.Len) - 2 // subtract leading Family, Len 240 for i := 0; i < n; i++ { 241 if pp.Path[i] == 0 { 242 // found early NUL; assume Len included the NUL 243 // or was overestimating. 244 n = i 245 break 246 } 247 } 248 bytes := (*[len(pp.Path)]byte)(unsafe.Pointer(&pp.Path[0]))[0:n] 249 sa.Name = string(bytes) 250 return sa, nil 251 252 case AF_INET: 253 pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa)) 254 sa := new(SockaddrInet4) 255 p := (*[2]byte)(unsafe.Pointer(&pp.Port)) 256 sa.Port = int(p[0])<<8 + int(p[1]) 257 sa.Addr = pp.Addr 258 return sa, nil 259 260 case AF_INET6: 261 pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa)) 262 sa := new(SockaddrInet6) 263 p := (*[2]byte)(unsafe.Pointer(&pp.Port)) 264 sa.Port = int(p[0])<<8 + int(p[1]) 265 sa.ZoneId = pp.Scope_id 266 sa.Addr = pp.Addr 267 return sa, nil 268 } 269 return anyToSockaddrGOOS(fd, rsa) 270 } 271 272 func Accept(fd int) (nfd int, sa Sockaddr, err error) { 273 var rsa RawSockaddrAny 274 var len _Socklen = SizeofSockaddrAny 275 nfd, err = accept(fd, &rsa, &len) 276 if err != nil { 277 return 278 } 279 if (runtime.GOOS == "darwin" || runtime.GOOS == "ios") && len == 0 { 280 // Accepted socket has no address. 281 // This is likely due to a bug in xnu kernels, 282 // where instead of ECONNABORTED error socket 283 // is accepted, but has no address. 284 Close(nfd) 285 return 0, nil, ECONNABORTED 286 } 287 sa, err = anyToSockaddr(fd, &rsa) 288 if err != nil { 289 Close(nfd) 290 nfd = 0 291 } 292 return 293 } 294 295 func Getsockname(fd int) (sa Sockaddr, err error) { 296 var rsa RawSockaddrAny 297 var len _Socklen = SizeofSockaddrAny 298 if err = getsockname(fd, &rsa, &len); err != nil { 299 return 300 } 301 // TODO(jsing): DragonFly has a "bug" (see issue 3349), which should be 302 // reported upstream. 303 if runtime.GOOS == "dragonfly" && rsa.Addr.Family == AF_UNSPEC && rsa.Addr.Len == 0 { 304 rsa.Addr.Family = AF_UNIX 305 rsa.Addr.Len = SizeofSockaddrUnix 306 } 307 return anyToSockaddr(fd, &rsa) 308 } 309 310 //sysnb socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) 311 312 // GetsockoptString returns the string value of the socket option opt for the 313 // socket associated with fd at the given socket level. 314 func GetsockoptString(fd, level, opt int) (string, error) { 315 buf := make([]byte, 256) 316 vallen := _Socklen(len(buf)) 317 err := getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen) 318 if err != nil { 319 return "", err 320 } 321 return string(buf[:vallen-1]), nil 322 } 323 324 //sys recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) 325 //sys sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) 326 //sys recvmsg(s int, msg *Msghdr, flags int) (n int, err error) 327 328 func recvmsgRaw(fd int, p, oob []byte, flags int, rsa *RawSockaddrAny) (n, oobn int, recvflags int, err error) { 329 var msg Msghdr 330 msg.Name = (*byte)(unsafe.Pointer(rsa)) 331 msg.Namelen = uint32(SizeofSockaddrAny) 332 var iov Iovec 333 if len(p) > 0 { 334 iov.Base = (*byte)(unsafe.Pointer(&p[0])) 335 iov.SetLen(len(p)) 336 } 337 var dummy byte 338 if len(oob) > 0 { 339 // receive at least one normal byte 340 if len(p) == 0 { 341 iov.Base = &dummy 342 iov.SetLen(1) 343 } 344 msg.Control = (*byte)(unsafe.Pointer(&oob[0])) 345 msg.SetControllen(len(oob)) 346 } 347 msg.Iov = &iov 348 msg.Iovlen = 1 349 if n, err = recvmsg(fd, &msg, flags); err != nil { 350 return 351 } 352 oobn = int(msg.Controllen) 353 recvflags = int(msg.Flags) 354 return 355 } 356 357 //sys sendmsg(s int, msg *Msghdr, flags int) (n int, err error) 358 359 func sendmsgN(fd int, p, oob []byte, ptr unsafe.Pointer, salen _Socklen, flags int) (n int, err error) { 360 var msg Msghdr 361 msg.Name = (*byte)(unsafe.Pointer(ptr)) 362 msg.Namelen = uint32(salen) 363 var iov Iovec 364 if len(p) > 0 { 365 iov.Base = (*byte)(unsafe.Pointer(&p[0])) 366 iov.SetLen(len(p)) 367 } 368 var dummy byte 369 if len(oob) > 0 { 370 // send at least one normal byte 371 if len(p) == 0 { 372 iov.Base = &dummy 373 iov.SetLen(1) 374 } 375 msg.Control = (*byte)(unsafe.Pointer(&oob[0])) 376 msg.SetControllen(len(oob)) 377 } 378 msg.Iov = &iov 379 msg.Iovlen = 1 380 if n, err = sendmsg(fd, &msg, flags); err != nil { 381 return 0, err 382 } 383 if len(oob) > 0 && len(p) == 0 { 384 n = 0 385 } 386 return n, nil 387 } 388 389 //sys kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) 390 391 func Kevent(kq int, changes, events []Kevent_t, timeout *Timespec) (n int, err error) { 392 var change, event unsafe.Pointer 393 if len(changes) > 0 { 394 change = unsafe.Pointer(&changes[0]) 395 } 396 if len(events) > 0 { 397 event = unsafe.Pointer(&events[0]) 398 } 399 return kevent(kq, change, len(changes), event, len(events), timeout) 400 } 401 402 // sysctlmib translates name to mib number and appends any additional args. 403 func sysctlmib(name string, args ...int) ([]_C_int, error) { 404 // Translate name to mib number. 405 mib, err := nametomib(name) 406 if err != nil { 407 return nil, err 408 } 409 410 for _, a := range args { 411 mib = append(mib, _C_int(a)) 412 } 413 414 return mib, nil 415 } 416 417 func Sysctl(name string) (string, error) { 418 return SysctlArgs(name) 419 } 420 421 func SysctlArgs(name string, args ...int) (string, error) { 422 buf, err := SysctlRaw(name, args...) 423 if err != nil { 424 return "", err 425 } 426 n := len(buf) 427 428 // Throw away terminating NUL. 429 if n > 0 && buf[n-1] == '\x00' { 430 n-- 431 } 432 return string(buf[0:n]), nil 433 } 434 435 func SysctlUint32(name string) (uint32, error) { 436 return SysctlUint32Args(name) 437 } 438 439 func SysctlUint32Args(name string, args ...int) (uint32, error) { 440 mib, err := sysctlmib(name, args...) 441 if err != nil { 442 return 0, err 443 } 444 445 n := uintptr(4) 446 buf := make([]byte, 4) 447 if err := sysctl(mib, &buf[0], &n, nil, 0); err != nil { 448 return 0, err 449 } 450 if n != 4 { 451 return 0, EIO 452 } 453 return *(*uint32)(unsafe.Pointer(&buf[0])), nil 454 } 455 456 func SysctlUint64(name string, args ...int) (uint64, error) { 457 mib, err := sysctlmib(name, args...) 458 if err != nil { 459 return 0, err 460 } 461 462 n := uintptr(8) 463 buf := make([]byte, 8) 464 if err := sysctl(mib, &buf[0], &n, nil, 0); err != nil { 465 return 0, err 466 } 467 if n != 8 { 468 return 0, EIO 469 } 470 return *(*uint64)(unsafe.Pointer(&buf[0])), nil 471 } 472 473 func SysctlRaw(name string, args ...int) ([]byte, error) { 474 mib, err := sysctlmib(name, args...) 475 if err != nil { 476 return nil, err 477 } 478 479 // Find size. 480 n := uintptr(0) 481 if err := sysctl(mib, nil, &n, nil, 0); err != nil { 482 return nil, err 483 } 484 if n == 0 { 485 return nil, nil 486 } 487 488 // Read into buffer of that size. 489 buf := make([]byte, n) 490 if err := sysctl(mib, &buf[0], &n, nil, 0); err != nil { 491 return nil, err 492 } 493 494 // The actual call may return less than the original reported required 495 // size so ensure we deal with that. 496 return buf[:n], nil 497 } 498 499 func SysctlClockinfo(name string) (*Clockinfo, error) { 500 mib, err := sysctlmib(name) 501 if err != nil { 502 return nil, err 503 } 504 505 n := uintptr(SizeofClockinfo) 506 var ci Clockinfo 507 if err := sysctl(mib, (*byte)(unsafe.Pointer(&ci)), &n, nil, 0); err != nil { 508 return nil, err 509 } 510 if n != SizeofClockinfo { 511 return nil, EIO 512 } 513 return &ci, nil 514 } 515 516 func SysctlTimeval(name string) (*Timeval, error) { 517 mib, err := sysctlmib(name) 518 if err != nil { 519 return nil, err 520 } 521 522 var tv Timeval 523 n := uintptr(unsafe.Sizeof(tv)) 524 if err := sysctl(mib, (*byte)(unsafe.Pointer(&tv)), &n, nil, 0); err != nil { 525 return nil, err 526 } 527 if n != unsafe.Sizeof(tv) { 528 return nil, EIO 529 } 530 return &tv, nil 531 } 532 533 //sys utimes(path string, timeval *[2]Timeval) (err error) 534 535 func Utimes(path string, tv []Timeval) error { 536 if tv == nil { 537 return utimes(path, nil) 538 } 539 if len(tv) != 2 { 540 return EINVAL 541 } 542 return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) 543 } 544 545 func UtimesNano(path string, ts []Timespec) error { 546 if ts == nil { 547 err := utimensat(AT_FDCWD, path, nil, 0) 548 if err != ENOSYS { 549 return err 550 } 551 return utimes(path, nil) 552 } 553 if len(ts) != 2 { 554 return EINVAL 555 } 556 err := utimensat(AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0) 557 if err != ENOSYS { 558 return err 559 } 560 // Not as efficient as it could be because Timespec and 561 // Timeval have different types in the different OSes 562 tv := [2]Timeval{ 563 NsecToTimeval(TimespecToNsec(ts[0])), 564 NsecToTimeval(TimespecToNsec(ts[1])), 565 } 566 return utimes(path, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) 567 } 568 569 func UtimesNanoAt(dirfd int, path string, ts []Timespec, flags int) error { 570 if ts == nil { 571 return utimensat(dirfd, path, nil, flags) 572 } 573 if len(ts) != 2 { 574 return EINVAL 575 } 576 return utimensat(dirfd, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), flags) 577 } 578 579 //sys futimes(fd int, timeval *[2]Timeval) (err error) 580 581 func Futimes(fd int, tv []Timeval) error { 582 if tv == nil { 583 return futimes(fd, nil) 584 } 585 if len(tv) != 2 { 586 return EINVAL 587 } 588 return futimes(fd, (*[2]Timeval)(unsafe.Pointer(&tv[0]))) 589 } 590 591 //sys poll(fds *PollFd, nfds int, timeout int) (n int, err error) 592 593 func Poll(fds []PollFd, timeout int) (n int, err error) { 594 if len(fds) == 0 { 595 return poll(nil, 0, timeout) 596 } 597 return poll(&fds[0], len(fds), timeout) 598 } 599 600 // TODO: wrap 601 // Acct(name nil-string) (err error) 602 // Gethostuuid(uuid *byte, timeout *Timespec) (err error) 603 // Ptrace(req int, pid int, addr uintptr, data int) (ret uintptr, err error) 604 605 var mapper = &mmapper{ 606 active: make(map[*byte][]byte), 607 mmap: mmap, 608 munmap: munmap, 609 } 610 611 func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) { 612 return mapper.Mmap(fd, offset, length, prot, flags) 613 } 614 615 func Munmap(b []byte) (err error) { 616 return mapper.Munmap(b) 617 } 618 619 //sys Madvise(b []byte, behav int) (err error) 620 //sys Mlock(b []byte) (err error) 621 //sys Mlockall(flags int) (err error) 622 //sys Mprotect(b []byte, prot int) (err error) 623 //sys Msync(b []byte, flags int) (err error) 624 //sys Munlock(b []byte) (err error) 625 //sys Munlockall() (err error)