github.com/Kalvelign/golang-windows-sys-lib@v0.0.0-20221121121202-63da651435e1/unix/syscall_unix.go (about) 1 // Copyright 2009 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris 6 // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris 7 8 package unix 9 10 import ( 11 "bytes" 12 "sort" 13 "sync" 14 "syscall" 15 "unsafe" 16 ) 17 18 var ( 19 Stdin = 0 20 Stdout = 1 21 Stderr = 2 22 ) 23 24 // Do the interface allocations only once for common 25 // Errno values. 26 var ( 27 errEAGAIN error = syscall.EAGAIN 28 errEINVAL error = syscall.EINVAL 29 errENOENT error = syscall.ENOENT 30 ) 31 32 var ( 33 signalNameMapOnce sync.Once 34 signalNameMap map[string]syscall.Signal 35 ) 36 37 // errnoErr returns common boxed Errno values, to prevent 38 // allocations at runtime. 39 func errnoErr(e syscall.Errno) error { 40 switch e { 41 case 0: 42 return nil 43 case EAGAIN: 44 return errEAGAIN 45 case EINVAL: 46 return errEINVAL 47 case ENOENT: 48 return errENOENT 49 } 50 return e 51 } 52 53 // ErrnoName returns the error name for error number e. 54 func ErrnoName(e syscall.Errno) string { 55 i := sort.Search(len(errorList), func(i int) bool { 56 return errorList[i].num >= e 57 }) 58 if i < len(errorList) && errorList[i].num == e { 59 return errorList[i].name 60 } 61 return "" 62 } 63 64 // SignalName returns the signal name for signal number s. 65 func SignalName(s syscall.Signal) string { 66 i := sort.Search(len(signalList), func(i int) bool { 67 return signalList[i].num >= s 68 }) 69 if i < len(signalList) && signalList[i].num == s { 70 return signalList[i].name 71 } 72 return "" 73 } 74 75 // SignalNum returns the syscall.Signal for signal named s, 76 // or 0 if a signal with such name is not found. 77 // The signal name should start with "SIG". 78 func SignalNum(s string) syscall.Signal { 79 signalNameMapOnce.Do(func() { 80 signalNameMap = make(map[string]syscall.Signal, len(signalList)) 81 for _, signal := range signalList { 82 signalNameMap[signal.name] = signal.num 83 } 84 }) 85 return signalNameMap[s] 86 } 87 88 // clen returns the index of the first NULL byte in n or len(n) if n contains no NULL byte. 89 func clen(n []byte) int { 90 i := bytes.IndexByte(n, 0) 91 if i == -1 { 92 i = len(n) 93 } 94 return i 95 } 96 97 // Mmap manager, for use by operating system-specific implementations. 98 99 type mmapper struct { 100 sync.Mutex 101 active map[*byte][]byte // active mappings; key is last byte in mapping 102 mmap func(addr, length uintptr, prot, flags, fd int, offset int64) (uintptr, error) 103 munmap func(addr uintptr, length uintptr) error 104 } 105 106 func (m *mmapper) Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) { 107 if length <= 0 { 108 return nil, EINVAL 109 } 110 111 // Map the requested memory. 112 addr, errno := m.mmap(0, uintptr(length), prot, flags, fd, offset) 113 if errno != nil { 114 return nil, errno 115 } 116 117 // Use unsafe to convert addr into a []byte. 118 b := unsafe.Slice((*byte)(unsafe.Pointer(addr)), length) 119 120 // Register mapping in m and return it. 121 p := &b[cap(b)-1] 122 m.Lock() 123 defer m.Unlock() 124 m.active[p] = b 125 return b, nil 126 } 127 128 func (m *mmapper) Munmap(data []byte) (err error) { 129 if len(data) == 0 || len(data) != cap(data) { 130 return EINVAL 131 } 132 133 // Find the base of the mapping. 134 p := &data[cap(data)-1] 135 m.Lock() 136 defer m.Unlock() 137 b := m.active[p] 138 if b == nil || &b[0] != &data[0] { 139 return EINVAL 140 } 141 142 // Unmap the memory and update m. 143 if errno := m.munmap(uintptr(unsafe.Pointer(&b[0])), uintptr(len(b))); errno != nil { 144 return errno 145 } 146 delete(m.active, p) 147 return nil 148 } 149 150 func Read(fd int, p []byte) (n int, err error) { 151 n, err = read(fd, p) 152 if raceenabled { 153 if n > 0 { 154 raceWriteRange(unsafe.Pointer(&p[0]), n) 155 } 156 if err == nil { 157 raceAcquire(unsafe.Pointer(&ioSync)) 158 } 159 } 160 return 161 } 162 163 func Write(fd int, p []byte) (n int, err error) { 164 if raceenabled { 165 raceReleaseMerge(unsafe.Pointer(&ioSync)) 166 } 167 n, err = write(fd, p) 168 if raceenabled && n > 0 { 169 raceReadRange(unsafe.Pointer(&p[0]), n) 170 } 171 return 172 } 173 174 func Pread(fd int, p []byte, offset int64) (n int, err error) { 175 n, err = pread(fd, p, offset) 176 if raceenabled { 177 if n > 0 { 178 raceWriteRange(unsafe.Pointer(&p[0]), n) 179 } 180 if err == nil { 181 raceAcquire(unsafe.Pointer(&ioSync)) 182 } 183 } 184 return 185 } 186 187 func Pwrite(fd int, p []byte, offset int64) (n int, err error) { 188 if raceenabled { 189 raceReleaseMerge(unsafe.Pointer(&ioSync)) 190 } 191 n, err = pwrite(fd, p, offset) 192 if raceenabled && n > 0 { 193 raceReadRange(unsafe.Pointer(&p[0]), n) 194 } 195 return 196 } 197 198 // For testing: clients can set this flag to force 199 // creation of IPv6 sockets to return EAFNOSUPPORT. 200 var SocketDisableIPv6 bool 201 202 // Sockaddr represents a socket address. 203 type Sockaddr interface { 204 sockaddr() (ptr unsafe.Pointer, len _Socklen, err error) // lowercase; only we can define Sockaddrs 205 } 206 207 // SockaddrInet4 implements the Sockaddr interface for AF_INET type sockets. 208 type SockaddrInet4 struct { 209 Port int 210 Addr [4]byte 211 raw RawSockaddrInet4 212 } 213 214 // SockaddrInet6 implements the Sockaddr interface for AF_INET6 type sockets. 215 type SockaddrInet6 struct { 216 Port int 217 ZoneId uint32 218 Addr [16]byte 219 raw RawSockaddrInet6 220 } 221 222 // SockaddrUnix implements the Sockaddr interface for AF_UNIX type sockets. 223 type SockaddrUnix struct { 224 Name string 225 raw RawSockaddrUnix 226 } 227 228 func Bind(fd int, sa Sockaddr) (err error) { 229 ptr, n, err := sa.sockaddr() 230 if err != nil { 231 return err 232 } 233 return bind(fd, ptr, n) 234 } 235 236 func Connect(fd int, sa Sockaddr) (err error) { 237 ptr, n, err := sa.sockaddr() 238 if err != nil { 239 return err 240 } 241 return connect(fd, ptr, n) 242 } 243 244 func Getpeername(fd int) (sa Sockaddr, err error) { 245 var rsa RawSockaddrAny 246 var len _Socklen = SizeofSockaddrAny 247 if err = getpeername(fd, &rsa, &len); err != nil { 248 return 249 } 250 return anyToSockaddr(fd, &rsa) 251 } 252 253 func GetsockoptByte(fd, level, opt int) (value byte, err error) { 254 var n byte 255 vallen := _Socklen(1) 256 err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen) 257 return n, err 258 } 259 260 func GetsockoptInt(fd, level, opt int) (value int, err error) { 261 var n int32 262 vallen := _Socklen(4) 263 err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen) 264 return int(n), err 265 } 266 267 func GetsockoptInet4Addr(fd, level, opt int) (value [4]byte, err error) { 268 vallen := _Socklen(4) 269 err = getsockopt(fd, level, opt, unsafe.Pointer(&value[0]), &vallen) 270 return value, err 271 } 272 273 func GetsockoptIPMreq(fd, level, opt int) (*IPMreq, error) { 274 var value IPMreq 275 vallen := _Socklen(SizeofIPMreq) 276 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) 277 return &value, err 278 } 279 280 func GetsockoptIPv6Mreq(fd, level, opt int) (*IPv6Mreq, error) { 281 var value IPv6Mreq 282 vallen := _Socklen(SizeofIPv6Mreq) 283 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) 284 return &value, err 285 } 286 287 func GetsockoptIPv6MTUInfo(fd, level, opt int) (*IPv6MTUInfo, error) { 288 var value IPv6MTUInfo 289 vallen := _Socklen(SizeofIPv6MTUInfo) 290 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) 291 return &value, err 292 } 293 294 func GetsockoptICMPv6Filter(fd, level, opt int) (*ICMPv6Filter, error) { 295 var value ICMPv6Filter 296 vallen := _Socklen(SizeofICMPv6Filter) 297 err := getsockopt(fd, level, opt, unsafe.Pointer(&value), &vallen) 298 return &value, err 299 } 300 301 func GetsockoptLinger(fd, level, opt int) (*Linger, error) { 302 var linger Linger 303 vallen := _Socklen(SizeofLinger) 304 err := getsockopt(fd, level, opt, unsafe.Pointer(&linger), &vallen) 305 return &linger, err 306 } 307 308 func GetsockoptTimeval(fd, level, opt int) (*Timeval, error) { 309 var tv Timeval 310 vallen := _Socklen(unsafe.Sizeof(tv)) 311 err := getsockopt(fd, level, opt, unsafe.Pointer(&tv), &vallen) 312 return &tv, err 313 } 314 315 func GetsockoptUint64(fd, level, opt int) (value uint64, err error) { 316 var n uint64 317 vallen := _Socklen(8) 318 err = getsockopt(fd, level, opt, unsafe.Pointer(&n), &vallen) 319 return n, err 320 } 321 322 func Recvfrom(fd int, p []byte, flags int) (n int, from Sockaddr, err error) { 323 var rsa RawSockaddrAny 324 var len _Socklen = SizeofSockaddrAny 325 if n, err = recvfrom(fd, p, flags, &rsa, &len); err != nil { 326 return 327 } 328 if rsa.Addr.Family != AF_UNSPEC { 329 from, err = anyToSockaddr(fd, &rsa) 330 } 331 return 332 } 333 334 func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) { 335 var iov [1]Iovec 336 if len(p) > 0 { 337 iov[0].Base = &p[0] 338 iov[0].SetLen(len(p)) 339 } 340 var rsa RawSockaddrAny 341 n, oobn, recvflags, err = recvmsgRaw(fd, iov[:], oob, flags, &rsa) 342 // source address is only specified if the socket is unconnected 343 if rsa.Addr.Family != AF_UNSPEC { 344 from, err = anyToSockaddr(fd, &rsa) 345 } 346 return 347 } 348 349 // RecvmsgBuffers receives a message from a socket using the recvmsg 350 // system call. The flags are passed to recvmsg. Any non-control data 351 // read is scattered into the buffers slices. The results are: 352 // - n is the number of non-control data read into bufs 353 // - oobn is the number of control data read into oob; this may be interpreted using [ParseSocketControlMessage] 354 // - recvflags is flags returned by recvmsg 355 // - from is the address of the sender 356 func RecvmsgBuffers(fd int, buffers [][]byte, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) { 357 iov := make([]Iovec, len(buffers)) 358 for i := range buffers { 359 if len(buffers[i]) > 0 { 360 iov[i].Base = &buffers[i][0] 361 iov[i].SetLen(len(buffers[i])) 362 } else { 363 iov[i].Base = (*byte)(unsafe.Pointer(&_zero)) 364 } 365 } 366 var rsa RawSockaddrAny 367 n, oobn, recvflags, err = recvmsgRaw(fd, iov, oob, flags, &rsa) 368 if err == nil && rsa.Addr.Family != AF_UNSPEC { 369 from, err = anyToSockaddr(fd, &rsa) 370 } 371 return 372 } 373 374 func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) (err error) { 375 _, err = SendmsgN(fd, p, oob, to, flags) 376 return 377 } 378 379 func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) { 380 var iov [1]Iovec 381 if len(p) > 0 { 382 iov[0].Base = &p[0] 383 iov[0].SetLen(len(p)) 384 } 385 var ptr unsafe.Pointer 386 var salen _Socklen 387 if to != nil { 388 ptr, salen, err = to.sockaddr() 389 if err != nil { 390 return 0, err 391 } 392 } 393 return sendmsgN(fd, iov[:], oob, ptr, salen, flags) 394 } 395 396 // SendmsgBuffers sends a message on a socket to an address using the sendmsg 397 // system call. The flags are passed to sendmsg. Any non-control data written 398 // is gathered from buffers. The function returns the number of bytes written 399 // to the socket. 400 func SendmsgBuffers(fd int, buffers [][]byte, oob []byte, to Sockaddr, flags int) (n int, err error) { 401 iov := make([]Iovec, len(buffers)) 402 for i := range buffers { 403 if len(buffers[i]) > 0 { 404 iov[i].Base = &buffers[i][0] 405 iov[i].SetLen(len(buffers[i])) 406 } else { 407 iov[i].Base = (*byte)(unsafe.Pointer(&_zero)) 408 } 409 } 410 var ptr unsafe.Pointer 411 var salen _Socklen 412 if to != nil { 413 ptr, salen, err = to.sockaddr() 414 if err != nil { 415 return 0, err 416 } 417 } 418 return sendmsgN(fd, iov, oob, ptr, salen, flags) 419 } 420 421 func Send(s int, buf []byte, flags int) (err error) { 422 return sendto(s, buf, flags, nil, 0) 423 } 424 425 func Sendto(fd int, p []byte, flags int, to Sockaddr) (err error) { 426 var ptr unsafe.Pointer 427 var salen _Socklen 428 if to != nil { 429 ptr, salen, err = to.sockaddr() 430 if err != nil { 431 return err 432 } 433 } 434 return sendto(fd, p, flags, ptr, salen) 435 } 436 437 func SetsockoptByte(fd, level, opt int, value byte) (err error) { 438 return setsockopt(fd, level, opt, unsafe.Pointer(&value), 1) 439 } 440 441 func SetsockoptInt(fd, level, opt int, value int) (err error) { 442 var n = int32(value) 443 return setsockopt(fd, level, opt, unsafe.Pointer(&n), 4) 444 } 445 446 func SetsockoptInet4Addr(fd, level, opt int, value [4]byte) (err error) { 447 return setsockopt(fd, level, opt, unsafe.Pointer(&value[0]), 4) 448 } 449 450 func SetsockoptIPMreq(fd, level, opt int, mreq *IPMreq) (err error) { 451 return setsockopt(fd, level, opt, unsafe.Pointer(mreq), SizeofIPMreq) 452 } 453 454 func SetsockoptIPv6Mreq(fd, level, opt int, mreq *IPv6Mreq) (err error) { 455 return setsockopt(fd, level, opt, unsafe.Pointer(mreq), SizeofIPv6Mreq) 456 } 457 458 func SetsockoptICMPv6Filter(fd, level, opt int, filter *ICMPv6Filter) error { 459 return setsockopt(fd, level, opt, unsafe.Pointer(filter), SizeofICMPv6Filter) 460 } 461 462 func SetsockoptLinger(fd, level, opt int, l *Linger) (err error) { 463 return setsockopt(fd, level, opt, unsafe.Pointer(l), SizeofLinger) 464 } 465 466 func SetsockoptString(fd, level, opt int, s string) (err error) { 467 var p unsafe.Pointer 468 if len(s) > 0 { 469 p = unsafe.Pointer(&[]byte(s)[0]) 470 } 471 return setsockopt(fd, level, opt, p, uintptr(len(s))) 472 } 473 474 func SetsockoptTimeval(fd, level, opt int, tv *Timeval) (err error) { 475 return setsockopt(fd, level, opt, unsafe.Pointer(tv), unsafe.Sizeof(*tv)) 476 } 477 478 func SetsockoptUint64(fd, level, opt int, value uint64) (err error) { 479 return setsockopt(fd, level, opt, unsafe.Pointer(&value), 8) 480 } 481 482 func Socket(domain, typ, proto int) (fd int, err error) { 483 if domain == AF_INET6 && SocketDisableIPv6 { 484 return -1, EAFNOSUPPORT 485 } 486 fd, err = socket(domain, typ, proto) 487 return 488 } 489 490 func Socketpair(domain, typ, proto int) (fd [2]int, err error) { 491 var fdx [2]int32 492 err = socketpair(domain, typ, proto, &fdx) 493 if err == nil { 494 fd[0] = int(fdx[0]) 495 fd[1] = int(fdx[1]) 496 } 497 return 498 } 499 500 var ioSync int64 501 502 func CloseOnExec(fd int) { fcntl(fd, F_SETFD, FD_CLOEXEC) } 503 504 func SetNonblock(fd int, nonblocking bool) (err error) { 505 flag, err := fcntl(fd, F_GETFL, 0) 506 if err != nil { 507 return err 508 } 509 if nonblocking { 510 flag |= O_NONBLOCK 511 } else { 512 flag &= ^O_NONBLOCK 513 } 514 _, err = fcntl(fd, F_SETFL, flag) 515 return err 516 } 517 518 // Exec calls execve(2), which replaces the calling executable in the process 519 // tree. argv0 should be the full path to an executable ("/bin/ls") and the 520 // executable name should also be the first argument in argv (["ls", "-l"]). 521 // envv are the environment variables that should be passed to the new 522 // process (["USER=go", "PWD=/tmp"]). 523 func Exec(argv0 string, argv []string, envv []string) error { 524 return syscall.Exec(argv0, argv, envv) 525 } 526 527 // Lutimes sets the access and modification times tv on path. If path refers to 528 // a symlink, it is not dereferenced and the timestamps are set on the symlink. 529 // If tv is nil, the access and modification times are set to the current time. 530 // Otherwise tv must contain exactly 2 elements, with access time as the first 531 // element and modification time as the second element. 532 func Lutimes(path string, tv []Timeval) error { 533 if tv == nil { 534 return UtimesNanoAt(AT_FDCWD, path, nil, AT_SYMLINK_NOFOLLOW) 535 } 536 if len(tv) != 2 { 537 return EINVAL 538 } 539 ts := []Timespec{ 540 NsecToTimespec(TimevalToNsec(tv[0])), 541 NsecToTimespec(TimevalToNsec(tv[1])), 542 } 543 return UtimesNanoAt(AT_FDCWD, path, ts, AT_SYMLINK_NOFOLLOW) 544 } 545 546 // emptyIovec reports whether there are no bytes in the slice of Iovec. 547 func emptyIovecs(iov []Iovec) bool { 548 for i := range iov { 549 if iov[i].Len > 0 { 550 return false 551 } 552 } 553 return true 554 }