123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377 |
- // Copyright 2011 The Go Authors. All rights reserved.
- // Use of this source code is governed by a BSD-style
- // license that can be found in the LICENSE file.
- //go:build cgo && !netgo && (aix || darwin || dragonfly || freebsd || hurd || linux || netbsd || openbsd || solaris)
- package net
- /*
- #include <sys/types.h>
- #include <sys/socket.h>
- #include <netinet/in.h>
- #include <netdb.h>
- #include <unistd.h>
- #include <string.h>
- // If nothing else defined EAI_OVERFLOW, make sure it has a value.
- #ifndef EAI_OVERFLOW
- #define EAI_OVERFLOW -12
- #endif
- */
- import (
- "context"
- "syscall"
- "unsafe"
- )
- //extern getaddrinfo
- func libc_getaddrinfo(node *byte, service *byte, hints *syscall.Addrinfo, res **syscall.Addrinfo) int32
- //extern freeaddrinfo
- func libc_freeaddrinfo(res *syscall.Addrinfo)
- //extern gai_strerror
- func libc_gai_strerror(errcode int) *byte
- // bytePtrToString takes a NUL-terminated array of bytes and convert
- // it to a Go string.
- func bytePtrToString(p *byte) string {
- a := (*[10000]byte)(unsafe.Pointer(p))
- i := 0
- for a[i] != 0 {
- i++
- }
- return string(a[:i])
- }
- // An addrinfoErrno represents a getaddrinfo, getnameinfo-specific
- // error number. It's a signed number and a zero value is a non-error
- // by convention.
- type addrinfoErrno int
- func (eai addrinfoErrno) Error() string { return bytePtrToString(libc_gai_strerror(int(eai))) }
- func (eai addrinfoErrno) Temporary() bool { return eai == syscall.EAI_AGAIN }
- func (eai addrinfoErrno) Timeout() bool { return false }
- type portLookupResult struct {
- port int
- err error
- }
- type ipLookupResult struct {
- addrs []IPAddr
- cname string
- err error
- }
- type reverseLookupResult struct {
- names []string
- err error
- }
- func cgoLookupHost(ctx context.Context, name string) (hosts []string, err error, completed bool) {
- addrs, err, completed := cgoLookupIP(ctx, "ip", name)
- for _, addr := range addrs {
- hosts = append(hosts, addr.String())
- }
- return
- }
- func cgoLookupPort(ctx context.Context, network, service string) (port int, err error, completed bool) {
- var hints syscall.Addrinfo
- switch network {
- case "": // no hints
- case "tcp", "tcp4", "tcp6":
- hints.Ai_socktype = syscall.SOCK_STREAM
- hints.Ai_protocol = syscall.IPPROTO_TCP
- case "udp", "udp4", "udp6":
- hints.Ai_socktype = syscall.SOCK_DGRAM
- hints.Ai_protocol = syscall.IPPROTO_UDP
- default:
- return 0, &DNSError{Err: "unknown network", Name: network + "/" + service}, true
- }
- switch ipVersion(network) {
- case '4':
- hints.Ai_family = syscall.AF_INET
- case '6':
- hints.Ai_family = syscall.AF_INET6
- }
- if ctx.Done() == nil {
- port, err := cgoLookupServicePort(&hints, network, service)
- return port, err, true
- }
- result := make(chan portLookupResult, 1)
- go cgoPortLookup(result, &hints, network, service)
- select {
- case r := <-result:
- return r.port, r.err, true
- case <-ctx.Done():
- // Since there isn't a portable way to cancel the lookup,
- // we just let it finish and write to the buffered channel.
- return 0, mapErr(ctx.Err()), false
- }
- }
- func cgoLookupServicePort(hints *syscall.Addrinfo, network, service string) (port int, err error) {
- s, err := syscall.BytePtrFromString(service)
- if err != nil {
- return 0, err
- }
- // Lowercase the service name in the memory passed to C.
- for i := 0; i < len(service); i++ {
- bp := (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(s)) + uintptr(i)))
- *bp = lowerASCII(*bp)
- }
- var res *syscall.Addrinfo
- syscall.Entersyscall()
- gerrno := libc_getaddrinfo(nil, s, hints, &res)
- syscall.Exitsyscall()
- if gerrno != 0 {
- isTemporary := false
- switch gerrno {
- case syscall.EAI_SYSTEM:
- errno := syscall.GetErrno()
- if errno == 0 { // see golang.org/issue/6232
- errno = syscall.EMFILE
- }
- err = errno
- default:
- err = addrinfoErrno(gerrno)
- isTemporary = addrinfoErrno(gerrno).Temporary()
- }
- return 0, &DNSError{Err: err.Error(), Name: network + "/" + service, IsTemporary: isTemporary}
- }
- defer libc_freeaddrinfo(res)
- for r := res; r != nil; r = r.Ai_next {
- switch r.Ai_family {
- case syscall.AF_INET:
- sa := (*syscall.RawSockaddrInet4)(unsafe.Pointer(r.Ai_addr))
- p := (*[2]byte)(unsafe.Pointer(&sa.Port))
- return int(p[0])<<8 | int(p[1]), nil
- case syscall.AF_INET6:
- sa := (*syscall.RawSockaddrInet6)(unsafe.Pointer(r.Ai_addr))
- p := (*[2]byte)(unsafe.Pointer(&sa.Port))
- return int(p[0])<<8 | int(p[1]), nil
- }
- }
- return 0, &DNSError{Err: "unknown port", Name: network + "/" + service}
- }
- func cgoPortLookup(result chan<- portLookupResult, hints *syscall.Addrinfo, network, service string) {
- port, err := cgoLookupServicePort(hints, network, service)
- result <- portLookupResult{port, err}
- }
- func cgoLookupIPCNAME(network, name string) (addrs []IPAddr, cname string, err error) {
- acquireThread()
- defer releaseThread()
- var hints syscall.Addrinfo
- hints.Ai_flags = int32(cgoAddrInfoFlags)
- hints.Ai_socktype = syscall.SOCK_STREAM
- hints.Ai_family = syscall.AF_UNSPEC
- switch ipVersion(network) {
- case '4':
- hints.Ai_family = syscall.AF_INET
- case '6':
- hints.Ai_family = syscall.AF_INET6
- }
- h := syscall.StringBytePtr(name)
- var res *syscall.Addrinfo
- syscall.Entersyscall()
- gerrno := libc_getaddrinfo(h, nil, &hints, &res)
- syscall.Exitsyscall()
- if gerrno != 0 {
- isErrorNoSuchHost := false
- isTemporary := false
- switch gerrno {
- case syscall.EAI_SYSTEM:
- errno := syscall.GetErrno()
- if errno == 0 {
- // err should not be nil, but sometimes getaddrinfo returns
- // gerrno == C.EAI_SYSTEM with err == nil on Linux.
- // The report claims that it happens when we have too many
- // open files, so use syscall.EMFILE (too many open files in system).
- // Most system calls would return ENFILE (too many open files),
- // so at the least EMFILE should be easy to recognize if this
- // comes up again. golang.org/issue/6232.
- errno = syscall.EMFILE
- }
- err = errno
- case syscall.EAI_NONAME:
- err = errNoSuchHost
- isErrorNoSuchHost = true
- default:
- err = addrinfoErrno(gerrno)
- isTemporary = addrinfoErrno(gerrno).Temporary()
- }
- return nil, "", &DNSError{Err: err.Error(), Name: name, IsNotFound: isErrorNoSuchHost, IsTemporary: isTemporary}
- }
- defer libc_freeaddrinfo(res)
- if res != nil {
- cname = bytePtrToString((*byte)(unsafe.Pointer(res.Ai_canonname)))
- if cname == "" {
- cname = name
- }
- if len(cname) > 0 && cname[len(cname)-1] != '.' {
- cname += "."
- }
- }
- for r := res; r != nil; r = r.Ai_next {
- // We only asked for SOCK_STREAM, but check anyhow.
- if r.Ai_socktype != syscall.SOCK_STREAM {
- continue
- }
- switch r.Ai_family {
- case syscall.AF_INET:
- sa := (*syscall.RawSockaddrInet4)(unsafe.Pointer(r.Ai_addr))
- addr := IPAddr{IP: copyIP(sa.Addr[:])}
- addrs = append(addrs, addr)
- case syscall.AF_INET6:
- sa := (*syscall.RawSockaddrInet6)(unsafe.Pointer(r.Ai_addr))
- addr := IPAddr{IP: copyIP(sa.Addr[:]), Zone: zoneCache.name(int(sa.Scope_id))}
- addrs = append(addrs, addr)
- }
- }
- return addrs, cname, nil
- }
- func cgoIPLookup(result chan<- ipLookupResult, network, name string) {
- addrs, cname, err := cgoLookupIPCNAME(network, name)
- result <- ipLookupResult{addrs, cname, err}
- }
- func cgoLookupIP(ctx context.Context, network, name string) (addrs []IPAddr, err error, completed bool) {
- if ctx.Done() == nil {
- addrs, _, err = cgoLookupIPCNAME(network, name)
- return addrs, err, true
- }
- result := make(chan ipLookupResult, 1)
- go cgoIPLookup(result, network, name)
- select {
- case r := <-result:
- return r.addrs, r.err, true
- case <-ctx.Done():
- return nil, mapErr(ctx.Err()), false
- }
- }
- func cgoLookupCNAME(ctx context.Context, name string) (cname string, err error, completed bool) {
- if ctx.Done() == nil {
- _, cname, err = cgoLookupIPCNAME("ip", name)
- return cname, err, true
- }
- result := make(chan ipLookupResult, 1)
- go cgoIPLookup(result, "ip", name)
- select {
- case r := <-result:
- return r.cname, r.err, true
- case <-ctx.Done():
- return "", mapErr(ctx.Err()), false
- }
- }
- // These are roughly enough for the following:
- //
- // Source Encoding Maximum length of single name entry
- // Unicast DNS ASCII or <=253 + a NUL terminator
- // Unicode in RFC 5892 252 * total number of labels + delimiters + a NUL terminator
- // Multicast DNS UTF-8 in RFC 5198 or <=253 + a NUL terminator
- // the same as unicast DNS ASCII <=253 + a NUL terminator
- // Local database various depends on implementation
- const (
- nameinfoLen = 64
- maxNameinfoLen = 4096
- )
- func cgoLookupPTR(ctx context.Context, addr string) (names []string, err error, completed bool) {
- var zone string
- ip := parseIPv4(addr)
- if ip == nil {
- ip, zone = parseIPv6Zone(addr)
- }
- if ip == nil {
- return nil, &DNSError{Err: "invalid address", Name: addr}, true
- }
- sa, salen := cgoSockaddr(ip, zone)
- if sa == nil {
- return nil, &DNSError{Err: "invalid address " + ip.String(), Name: addr}, true
- }
- if ctx.Done() == nil {
- names, err := cgoLookupAddrPTR(addr, sa, salen)
- return names, err, true
- }
- result := make(chan reverseLookupResult, 1)
- go cgoReverseLookup(result, addr, sa, salen)
- select {
- case r := <-result:
- return r.names, r.err, true
- case <-ctx.Done():
- return nil, mapErr(ctx.Err()), false
- }
- }
- func cgoLookupAddrPTR(addr string, sa *syscall.RawSockaddr, salen syscall.Socklen_t) (names []string, err error) {
- acquireThread()
- defer releaseThread()
- var gerrno int
- var b []byte
- for l := nameinfoLen; l <= maxNameinfoLen; l *= 2 {
- b = make([]byte, l)
- gerrno, err = cgoNameinfoPTR(b, sa, salen)
- if gerrno == 0 || gerrno != syscall.EAI_OVERFLOW {
- break
- }
- }
- if gerrno != 0 {
- isTemporary := false
- switch gerrno {
- case syscall.EAI_SYSTEM:
- if err == nil { // see golang.org/issue/6232
- err = syscall.EMFILE
- }
- default:
- err = addrinfoErrno(gerrno)
- isTemporary = addrinfoErrno(gerrno).Temporary()
- }
- return nil, &DNSError{Err: err.Error(), Name: addr, IsTemporary: isTemporary}
- }
- for i := 0; i < len(b); i++ {
- if b[i] == 0 {
- b = b[:i]
- break
- }
- }
- return []string{absDomainName(string(b))}, nil
- }
- func cgoReverseLookup(result chan<- reverseLookupResult, addr string, sa *syscall.RawSockaddr, salen syscall.Socklen_t) {
- names, err := cgoLookupAddrPTR(addr, sa, salen)
- result <- reverseLookupResult{names, err}
- }
- func cgoSockaddr(ip IP, zone string) (*syscall.RawSockaddr, syscall.Socklen_t) {
- if ip4 := ip.To4(); ip4 != nil {
- return cgoSockaddrInet4(ip4), syscall.Socklen_t(syscall.SizeofSockaddrInet4)
- }
- if ip6 := ip.To16(); ip6 != nil {
- return cgoSockaddrInet6(ip6, zoneCache.index(zone)), syscall.Socklen_t(syscall.SizeofSockaddrInet6)
- }
- return nil, 0
- }
- func copyIP(x IP) IP {
- if len(x) < 16 {
- return x.To16()
- }
- y := make(IP, len(x))
- copy(y, x)
- return y
- }
|