Skip to content
Snippets Groups Projects
dnsclient_unix.go 6.99 KiB
Newer Older
  • Learn to ignore specific revisions
  • // Copyright 2009 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.
    
    
    // +build darwin freebsd linux netbsd openbsd
    
    // DNS client: see RFC 1035.
    // Has to be linked into package net for Dial.
    
    // TODO(rsc):
    //	Check periodically whether /etc/resolv.conf has changed.
    //	Could potentially handle many outstanding lookups faster.
    //	Could have a small cache.
    //	Random UDP source port (net.Dial should do that for us).
    //	Random request IDs.
    
    package net
    
    import (
    
    	"sync"
    	"time"
    )
    
    // Send a request on the connection and hope for a reply.
    // Up to cfg.attempts attempts.
    
    func exchange(cfg *dnsConfig, c Conn, name string, qtype uint16) (*dnsMsg, error) {
    
    		return nil, &DNSError{Err: "name too long", Name: name}
    
    Russ Cox's avatar
    Russ Cox committed
    	out.id = uint16(rand.Int()) ^ uint16(time.Now().UnixNano())
    
    	out.question = []dnsQuestion{
    		{name, qtype, dnsClassINET},
    	}
    	out.recursion_desired = true
    	msg, ok := out.Pack()
    	if !ok {
    
    		return nil, &DNSError{Err: "internal error - cannot pack message", Name: name}
    
    	}
    
    	for attempt := 0; attempt < cfg.attempts; attempt++ {
    		n, err := c.Write(msg)
    		if err != nil {
    			return nil, err
    		}
    
    
    		if cfg.timeout == 0 {
    
    			c.SetReadDeadline(noDeadline)
    
    		} else {
    			c.SetReadDeadline(time.Now().Add(time.Duration(cfg.timeout) * time.Second))
    		}
    
    
    		buf := make([]byte, 2000) // More than enough.
    		n, err = c.Read(buf)
    		if err != nil {
    			if e, ok := err.(Error); ok && e.Timeout() {
    				continue
    			}
    			return nil, err
    		}
    		buf = buf[0:n]
    		in := new(dnsMsg)
    		if !in.Unpack(buf) || in.id != out.id {
    			continue
    		}
    		return in, nil
    	}
    	var server string
    	if a := c.RemoteAddr(); a != nil {
    		server = a.String()
    	}
    
    	return nil, &DNSError{Err: "no answer from server", Name: name, Server: server, IsTimeout: true}
    
    }
    
    // Do a lookup for a single name, which must be rooted
    // (otherwise answer will not find the answers).
    
    func tryOneName(cfg *dnsConfig, name string, qtype uint16) (cname string, addrs []dnsRR, err error) {
    
    		return "", nil, &DNSError{Err: "no DNS servers", Name: name}
    
    	}
    	for i := 0; i < len(cfg.servers); i++ {
    		// Calling Dial here is scary -- we have to be sure
    		// not to dial a name that will require a DNS lookup,
    		// or Dial will call back here to translate it.
    		// The DNS config parser has already checked that
    		// all the cfg.servers[i] are IP addresses, which
    		// Dial will use without a DNS lookup.
    		server := cfg.servers[i] + ":53"
    		c, cerr := Dial("udp", server)
    		if cerr != nil {
    			err = cerr
    			continue
    		}
    		msg, merr := exchange(cfg, c, name, qtype)
    		c.Close()
    		if merr != nil {
    			err = merr
    			continue
    		}
    		cname, addrs, err = answer(name, server, msg, qtype)
    
    		if err == nil || err.(*DNSError).Err == noSuchHost {
    
    			break
    		}
    	}
    	return
    }
    
    func convertRR_A(records []dnsRR) []IP {
    	addrs := make([]IP, len(records))
    	for i, rr := range records {
    		a := rr.(*dnsRR_A).A
    		addrs[i] = IPv4(byte(a>>24), byte(a>>16), byte(a>>8), byte(a))
    	}
    	return addrs
    }
    
    func convertRR_AAAA(records []dnsRR) []IP {
    	addrs := make([]IP, len(records))
    	for i, rr := range records {
    
    		a := make(IP, IPv6len)
    
    		copy(a, rr.(*dnsRR_AAAA).AAAA[:])
    		addrs[i] = a
    	}
    	return addrs
    }
    
    var cfg *dnsConfig
    
    var dnserr error
    
    
    func loadConfig() { cfg, dnserr = dnsReadConfig() }
    
    var onceLoadConfig sync.Once
    
    
    func lookup(name string, qtype uint16) (cname string, addrs []dnsRR, err error) {
    
    		return name, nil, &DNSError{Err: "invalid domain name", Name: name}
    
    	}
    	onceLoadConfig.Do(loadConfig)
    	if dnserr != nil || cfg == nil {
    		err = dnserr
    		return
    	}
    	// If name is rooted (trailing dot) or has enough dots,
    	// try it by itself first.
    	rooted := len(name) > 0 && name[len(name)-1] == '.'
    	if rooted || count(name, '.') >= cfg.ndots {
    		rname := name
    		if !rooted {
    			rname += "."
    		}
    		// Can try as ordinary name.
    		cname, addrs, err = tryOneName(cfg, rname, qtype)
    		if err == nil {
    			return
    		}
    	}
    	if rooted {
    		return
    	}
    
    	// Otherwise, try suffixes.
    	for i := 0; i < len(cfg.search); i++ {
    		rname := name + "." + cfg.search[i]
    		if rname[len(rname)-1] != '.' {
    			rname += "."
    		}
    		cname, addrs, err = tryOneName(cfg, rname, qtype)
    		if err == nil {
    			return
    		}
    	}
    
    	// Last ditch effort: try unsuffixed.
    	rname := name
    	if !rooted {
    		rname += "."
    	}
    	cname, addrs, err = tryOneName(cfg, rname, qtype)
    	if err == nil {
    		return
    	}
    	return
    }
    
    // goLookupHost is the native Go implementation of LookupHost.
    // Used only if cgoLookupHost refuses to handle the request
    // (that is, only if cgoLookupHost is the stub in cgo_stub.go).
    // Normally we let cgo use the C library resolver instead of
    // depending on our lookup code, so that Go and C get the same
    // answers.
    
    func goLookupHost(name string) (addrs []string, err error) {
    
    	// Use entries from /etc/hosts if they match.
    	addrs = lookupStaticHost(name)
    	if len(addrs) > 0 {
    		return
    	}
    	onceLoadConfig.Do(loadConfig)
    	if dnserr != nil || cfg == nil {
    		err = dnserr
    		return
    	}
    	ips, err := goLookupIP(name)
    	if err != nil {
    		return
    	}
    	addrs = make([]string, 0, len(ips))
    	for _, ip := range ips {
    		addrs = append(addrs, ip.String())
    	}
    	return
    }
    
    // goLookupIP is the native Go implementation of LookupIP.
    // Used only if cgoLookupIP refuses to handle the request
    // (that is, only if cgoLookupIP is the stub in cgo_stub.go).
    // Normally we let cgo use the C library resolver instead of
    // depending on our lookup code, so that Go and C get the same
    // answers.
    
    func goLookupIP(name string) (addrs []IP, err error) {
    
    	// Use entries from /etc/hosts if possible.
    	haddrs := lookupStaticHost(name)
    	if len(haddrs) > 0 {
    		for _, haddr := range haddrs {
    			if ip := ParseIP(haddr); ip != nil {
    				addrs = append(addrs, ip)
    			}
    		}
    		if len(addrs) > 0 {
    			return
    		}
    	}
    
    	onceLoadConfig.Do(loadConfig)
    	if dnserr != nil || cfg == nil {
    		err = dnserr
    		return
    	}
    	var records []dnsRR
    	var cname string
    
    	var err4, err6 error
    	cname, records, err4 = lookup(name, dnsTypeA)
    
    	addrs = convertRR_A(records)
    	if cname != "" {
    		name = cname
    	}
    
    	_, records, err6 = lookup(name, dnsTypeAAAA)
    	if err4 != nil && err6 == nil {
    		// Ignore A error because AAAA lookup succeeded.
    		err4 = nil
    
    	if err6 != nil && len(addrs) > 0 {
    		// Ignore AAAA error because A lookup succeeded.
    		err6 = nil
    
    	if err4 != nil {
    		return nil, err4
    	}
    	if err6 != nil {
    		return nil, err6
    	}
    
    
    	addrs = append(addrs, convertRR_AAAA(records)...)
    
    }
    
    // goLookupCNAME is the native Go implementation of LookupCNAME.
    // Used only if cgoLookupCNAME refuses to handle the request
    // (that is, only if cgoLookupCNAME is the stub in cgo_stub.go).
    // Normally we let cgo use the C library resolver instead of
    // depending on our lookup code, so that Go and C get the same
    // answers.
    
    func goLookupCNAME(name string) (cname string, err error) {
    
    	onceLoadConfig.Do(loadConfig)
    	if dnserr != nil || cfg == nil {
    		err = dnserr
    		return
    	}
    	_, rr, err := lookup(name, dnsTypeCNAME)
    	if err != nil {
    		return
    	}
    	cname = rr[0].(*dnsRR_CNAME).Cname
    	return
    }