2011-06-12 18:22:31 -06:00
|
|
|
// 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.
|
|
|
|
|
all: merge NaCl branch (part 1)
See golang.org/s/go13nacl for design overview.
This CL is the mostly mechanical changes from rsc's Go 1.2 based NaCl branch, specifically 39cb35750369 to 500771b477cf from https://code.google.com/r/rsc-go13nacl. This CL does not include working NaCl support, there are probably two or three more large merges to come.
CL 15750044 is not included as it involves more invasive changes to the linker which will need to be merged separately.
The exact change lists included are
15050047: syscall: support for Native Client
15360044: syscall: unzip implementation for Native Client
15370044: syscall: Native Client SRPC implementation
15400047: cmd/dist, cmd/go, go/build, test: support for Native Client
15410048: runtime: support for Native Client
15410049: syscall: file descriptor table for Native Client
15410050: syscall: in-memory file system for Native Client
15440048: all: update +build lines for Native Client port
15540045: cmd/6g, cmd/8g, cmd/gc: support for Native Client
15570045: os: support for Native Client
15680044: crypto/..., hash/crc32, reflect, sync/atomic: support for amd64p32
15690044: net: support for Native Client
15690048: runtime: support for fake time like on Go Playground
15690051: build: disable various tests on Native Client
LGTM=rsc
R=rsc
CC=golang-codereviews
https://golang.org/cl/68150047
2014-02-25 07:47:42 -07:00
|
|
|
// +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris
|
build: add build comments to core packages
The go/build package already recognizes
system-specific file names like
mycode_darwin.go
mycode_darwin_386.go
mycode_386.s
However, it is also common to write files that
apply to multiple architectures, so a recent CL added
to go/build the ability to process comments
listing a set of conditions for building. For example:
// +build darwin freebsd openbsd/386
says that this file should be compiled only on
OS X, FreeBSD, or 32-bit x86 OpenBSD systems.
These conventions are not yet documented
(hence this long CL description).
This CL adds build comments to the multi-system
files in the core library, a step toward making it
possible to use go/build to build them.
With this change go/build can handle crypto/rand,
exec, net, path/filepath, os/user, and time.
os and syscall need additional adjustments.
R=golang-dev, r, gri, r, gustavo
CC=golang-dev
https://golang.org/cl/5011046
2011-09-15 14:48:57 -06:00
|
|
|
|
2011-06-12 18:22:31 -06:00
|
|
|
// DNS client: see RFC 1035.
|
|
|
|
// Has to be linked into package net for Dial.
|
|
|
|
|
|
|
|
// TODO(rsc):
|
|
|
|
// 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 (
|
2014-08-05 18:58:47 -06:00
|
|
|
"errors"
|
2013-08-13 10:44:12 -06:00
|
|
|
"io"
|
2011-11-08 16:41:54 -07:00
|
|
|
"math/rand"
|
2014-05-14 18:11:00 -06:00
|
|
|
"os"
|
2011-06-12 18:22:31 -06:00
|
|
|
"sync"
|
|
|
|
"time"
|
|
|
|
)
|
|
|
|
|
2014-08-05 18:58:47 -06:00
|
|
|
// A dnsConn represents a DNS transport endpoint.
|
|
|
|
type dnsConn interface {
|
|
|
|
Conn
|
|
|
|
|
|
|
|
// readDNSResponse reads a DNS response message from the DNS
|
|
|
|
// transport endpoint and returns the received DNS response
|
|
|
|
// message.
|
|
|
|
readDNSResponse() (*dnsMsg, error)
|
|
|
|
|
|
|
|
// writeDNSQuery writes a DNS query message to the DNS
|
|
|
|
// connection endpoint.
|
|
|
|
writeDNSQuery(*dnsMsg) error
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *UDPConn) readDNSResponse() (*dnsMsg, error) {
|
|
|
|
b := make([]byte, 512) // see RFC 1035
|
|
|
|
n, err := c.Read(b)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
msg := &dnsMsg{}
|
|
|
|
if !msg.Unpack(b[:n]) {
|
|
|
|
return nil, errors.New("cannot unmarshal DNS message")
|
|
|
|
}
|
|
|
|
return msg, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *UDPConn) writeDNSQuery(msg *dnsMsg) error {
|
|
|
|
b, ok := msg.Pack()
|
|
|
|
if !ok {
|
|
|
|
return errors.New("cannot marshal DNS message")
|
|
|
|
}
|
|
|
|
if _, err := c.Write(b); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *TCPConn) readDNSResponse() (*dnsMsg, error) {
|
|
|
|
b := make([]byte, 1280) // 1280 is a reasonable initial size for IP over Ethernet, see RFC 4035
|
|
|
|
if _, err := io.ReadFull(c, b[:2]); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
l := int(b[0])<<8 | int(b[1])
|
|
|
|
if l > len(b) {
|
|
|
|
b = make([]byte, l)
|
2011-06-12 18:22:31 -06:00
|
|
|
}
|
2014-08-05 18:58:47 -06:00
|
|
|
n, err := io.ReadFull(c, b[:l])
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
2011-06-12 18:22:31 -06:00
|
|
|
}
|
2014-08-05 18:58:47 -06:00
|
|
|
msg := &dnsMsg{}
|
|
|
|
if !msg.Unpack(b[:n]) {
|
|
|
|
return nil, errors.New("cannot unmarshal DNS message")
|
|
|
|
}
|
|
|
|
return msg, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *TCPConn) writeDNSQuery(msg *dnsMsg) error {
|
|
|
|
b, ok := msg.Pack()
|
2011-06-12 18:22:31 -06:00
|
|
|
if !ok {
|
2014-08-05 18:58:47 -06:00
|
|
|
return errors.New("cannot marshal DNS message")
|
2011-06-12 18:22:31 -06:00
|
|
|
}
|
2014-08-05 18:58:47 -06:00
|
|
|
l := uint16(len(b))
|
|
|
|
b = append([]byte{byte(l >> 8), byte(l)}, b...)
|
|
|
|
if _, err := c.Write(b); err != nil {
|
|
|
|
return err
|
2013-08-13 10:44:12 -06:00
|
|
|
}
|
2014-08-05 18:58:47 -06:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (d *Dialer) dialDNS(network, server string) (dnsConn, error) {
|
|
|
|
switch network {
|
|
|
|
case "tcp", "tcp4", "tcp6", "udp", "udp4", "udp6":
|
|
|
|
default:
|
|
|
|
return nil, UnknownNetworkError(network)
|
|
|
|
}
|
|
|
|
// 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.
|
|
|
|
c, err := d.Dial(network, server)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
switch network {
|
|
|
|
case "tcp", "tcp4", "tcp6":
|
|
|
|
return c.(*TCPConn), nil
|
|
|
|
case "udp", "udp4", "udp6":
|
|
|
|
return c.(*UDPConn), nil
|
|
|
|
}
|
|
|
|
panic("unreachable")
|
|
|
|
}
|
|
|
|
|
|
|
|
// exchange sends a query on the connection and hopes for a response.
|
|
|
|
func exchange(server, name string, qtype uint16, timeout time.Duration) (*dnsMsg, error) {
|
|
|
|
d := Dialer{Timeout: timeout}
|
|
|
|
out := dnsMsg{
|
|
|
|
dnsMsgHdr: dnsMsgHdr{
|
|
|
|
recursion_desired: true,
|
|
|
|
},
|
|
|
|
question: []dnsQuestion{
|
|
|
|
{name, qtype, dnsClassINET},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
for _, network := range []string{"udp", "tcp"} {
|
|
|
|
c, err := d.dialDNS(network, server)
|
2011-06-12 18:22:31 -06:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2014-08-05 18:58:47 -06:00
|
|
|
defer c.Close()
|
|
|
|
if timeout > 0 {
|
|
|
|
c.SetDeadline(time.Now().Add(timeout))
|
2012-01-18 17:24:06 -07:00
|
|
|
}
|
2014-08-05 18:58:47 -06:00
|
|
|
out.id = uint16(rand.Int()) ^ uint16(time.Now().UnixNano())
|
|
|
|
if err := c.writeDNSQuery(&out); err != nil {
|
|
|
|
return nil, err
|
2013-08-13 10:44:12 -06:00
|
|
|
}
|
2014-08-05 18:58:47 -06:00
|
|
|
in, err := c.readDNSResponse()
|
2011-06-12 18:22:31 -06:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2014-08-05 18:58:47 -06:00
|
|
|
if in.id != out.id {
|
|
|
|
return nil, errors.New("DNS message ID mismatch")
|
|
|
|
}
|
|
|
|
if in.truncated { // see RFC 5966
|
2011-06-12 18:22:31 -06:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
return in, nil
|
|
|
|
}
|
2014-08-05 18:58:47 -06:00
|
|
|
return nil, errors.New("no answer from DNS server")
|
2011-06-12 18:22:31 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// Do a lookup for a single name, which must be rooted
|
|
|
|
// (otherwise answer will not find the answers).
|
2014-08-05 18:58:47 -06:00
|
|
|
func tryOneName(cfg *dnsConfig, name string, qtype uint16) (string, []dnsRR, error) {
|
2011-06-12 18:22:31 -06:00
|
|
|
if len(cfg.servers) == 0 {
|
2011-11-01 20:05:34 -06:00
|
|
|
return "", nil, &DNSError{Err: "no DNS servers", Name: name}
|
2011-06-12 18:22:31 -06:00
|
|
|
}
|
2014-08-05 18:58:47 -06:00
|
|
|
if len(name) >= 256 {
|
|
|
|
return "", nil, &DNSError{Err: "DNS name too long", Name: name}
|
|
|
|
}
|
|
|
|
timeout := time.Duration(cfg.timeout) * time.Second
|
|
|
|
var lastErr error
|
|
|
|
for _, server := range cfg.servers {
|
|
|
|
server += ":53"
|
|
|
|
lastErr = &DNSError{
|
|
|
|
Err: "no answer from DNS server",
|
|
|
|
Name: name,
|
|
|
|
Server: server,
|
|
|
|
IsTimeout: true,
|
2011-06-12 18:22:31 -06:00
|
|
|
}
|
2014-08-05 18:58:47 -06:00
|
|
|
for i := 0; i < cfg.attempts; i++ {
|
|
|
|
msg, err := exchange(server, name, qtype, timeout)
|
|
|
|
if err != nil {
|
|
|
|
if nerr, ok := err.(Error); ok && nerr.Timeout() {
|
|
|
|
lastErr = &DNSError{
|
|
|
|
Err: nerr.Error(),
|
|
|
|
Name: name,
|
|
|
|
Server: server,
|
|
|
|
IsTimeout: true,
|
|
|
|
}
|
|
|
|
continue
|
|
|
|
|
|
|
|
}
|
|
|
|
lastErr = &DNSError{
|
|
|
|
Err: err.Error(),
|
|
|
|
Name: name,
|
|
|
|
Server: server,
|
|
|
|
}
|
|
|
|
break
|
2013-08-13 10:44:12 -06:00
|
|
|
}
|
2014-08-05 18:58:47 -06:00
|
|
|
cname, addrs, err := answer(name, server, msg, qtype)
|
|
|
|
if err == nil || err.(*DNSError).Err == noSuchHost {
|
|
|
|
return cname, addrs, err
|
2013-08-13 10:44:12 -06:00
|
|
|
}
|
2014-08-05 18:58:47 -06:00
|
|
|
lastErr = err
|
2011-06-12 18:22:31 -06:00
|
|
|
}
|
|
|
|
}
|
2014-08-05 18:58:47 -06:00
|
|
|
return "", nil, lastErr
|
2011-06-12 18:22:31 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
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 {
|
2011-08-24 11:59:33 -06:00
|
|
|
a := make(IP, IPv6len)
|
2011-06-12 18:22:31 -06:00
|
|
|
copy(a, rr.(*dnsRR_AAAA).AAAA[:])
|
|
|
|
addrs[i] = a
|
|
|
|
}
|
|
|
|
return addrs
|
|
|
|
}
|
|
|
|
|
2014-05-14 18:11:00 -06:00
|
|
|
var cfg struct {
|
|
|
|
ch chan struct{}
|
|
|
|
mu sync.RWMutex // protects dnsConfig and dnserr
|
|
|
|
dnsConfig *dnsConfig
|
|
|
|
dnserr error
|
|
|
|
}
|
|
|
|
var onceLoadConfig sync.Once
|
2011-06-12 18:22:31 -06:00
|
|
|
|
2013-12-18 09:26:36 -07:00
|
|
|
// Assume dns config file is /etc/resolv.conf here
|
2014-05-14 18:11:00 -06:00
|
|
|
func loadDefaultConfig() {
|
|
|
|
loadConfig("/etc/resolv.conf", 5*time.Second, nil)
|
|
|
|
}
|
2011-06-12 18:22:31 -06:00
|
|
|
|
2014-05-14 18:11:00 -06:00
|
|
|
func loadConfig(resolvConfPath string, reloadTime time.Duration, quit <-chan chan struct{}) {
|
|
|
|
var mtime time.Time
|
|
|
|
cfg.ch = make(chan struct{}, 1)
|
|
|
|
if fi, err := os.Stat(resolvConfPath); err != nil {
|
|
|
|
cfg.dnserr = err
|
|
|
|
} else {
|
|
|
|
mtime = fi.ModTime()
|
|
|
|
cfg.dnsConfig, cfg.dnserr = dnsReadConfig(resolvConfPath)
|
|
|
|
}
|
|
|
|
go func() {
|
|
|
|
for {
|
|
|
|
time.Sleep(reloadTime)
|
|
|
|
select {
|
|
|
|
case qresp := <-quit:
|
|
|
|
qresp <- struct{}{}
|
|
|
|
return
|
|
|
|
case <-cfg.ch:
|
|
|
|
}
|
|
|
|
|
|
|
|
// In case of error, we keep the previous config
|
|
|
|
fi, err := os.Stat(resolvConfPath)
|
|
|
|
if err != nil {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
// If the resolv.conf mtime didn't change, do not reload
|
|
|
|
m := fi.ModTime()
|
|
|
|
if m.Equal(mtime) {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
mtime = m
|
|
|
|
// In case of error, we keep the previous config
|
|
|
|
ncfg, err := dnsReadConfig(resolvConfPath)
|
|
|
|
if err != nil || len(ncfg.servers) == 0 {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
cfg.mu.Lock()
|
|
|
|
cfg.dnsConfig = ncfg
|
|
|
|
cfg.dnserr = nil
|
|
|
|
cfg.mu.Unlock()
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
}
|
2011-06-12 18:22:31 -06:00
|
|
|
|
2011-11-01 20:05:34 -06:00
|
|
|
func lookup(name string, qtype uint16) (cname string, addrs []dnsRR, err error) {
|
2011-06-12 18:22:31 -06:00
|
|
|
if !isDomainName(name) {
|
2011-11-01 20:05:34 -06:00
|
|
|
return name, nil, &DNSError{Err: "invalid domain name", Name: name}
|
2011-06-12 18:22:31 -06:00
|
|
|
}
|
2014-05-14 18:11:00 -06:00
|
|
|
onceLoadConfig.Do(loadDefaultConfig)
|
|
|
|
|
|
|
|
select {
|
|
|
|
case cfg.ch <- struct{}{}:
|
|
|
|
default:
|
|
|
|
}
|
|
|
|
|
|
|
|
cfg.mu.RLock()
|
|
|
|
defer cfg.mu.RUnlock()
|
|
|
|
|
|
|
|
if cfg.dnserr != nil || cfg.dnsConfig == nil {
|
|
|
|
err = cfg.dnserr
|
2011-06-12 18:22:31 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
// If name is rooted (trailing dot) or has enough dots,
|
|
|
|
// try it by itself first.
|
|
|
|
rooted := len(name) > 0 && name[len(name)-1] == '.'
|
2014-05-14 18:11:00 -06:00
|
|
|
if rooted || count(name, '.') >= cfg.dnsConfig.ndots {
|
2011-06-12 18:22:31 -06:00
|
|
|
rname := name
|
|
|
|
if !rooted {
|
|
|
|
rname += "."
|
|
|
|
}
|
|
|
|
// Can try as ordinary name.
|
2014-05-14 18:11:00 -06:00
|
|
|
cname, addrs, err = tryOneName(cfg.dnsConfig, rname, qtype)
|
2014-08-29 16:50:50 -06:00
|
|
|
if rooted || err == nil {
|
2011-06-12 18:22:31 -06:00
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, try suffixes.
|
2014-05-14 18:11:00 -06:00
|
|
|
for i := 0; i < len(cfg.dnsConfig.search); i++ {
|
|
|
|
rname := name + "." + cfg.dnsConfig.search[i]
|
2011-06-12 18:22:31 -06:00
|
|
|
if rname[len(rname)-1] != '.' {
|
|
|
|
rname += "."
|
|
|
|
}
|
2014-05-14 18:11:00 -06:00
|
|
|
cname, addrs, err = tryOneName(cfg.dnsConfig, rname, qtype)
|
2011-06-12 18:22:31 -06:00
|
|
|
if err == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-29 16:50:50 -06:00
|
|
|
// Last ditch effort: try unsuffixed only if we haven't already,
|
|
|
|
// that is, name is not rooted and has less than ndots dots.
|
|
|
|
if count(name, '.') < cfg.dnsConfig.ndots {
|
|
|
|
cname, addrs, err = tryOneName(cfg.dnsConfig, name+".", qtype)
|
|
|
|
if err == nil {
|
|
|
|
return
|
|
|
|
}
|
2011-06-12 18:22:31 -06:00
|
|
|
}
|
2014-08-29 16:50:50 -06:00
|
|
|
|
2013-10-02 20:09:54 -06:00
|
|
|
if e, ok := err.(*DNSError); ok {
|
|
|
|
// Show original name passed to lookup, not suffixed one.
|
|
|
|
// In general we might have tried many suffixes; showing
|
|
|
|
// just one is misleading. See also golang.org/issue/6324.
|
|
|
|
e.Name = name
|
|
|
|
}
|
2011-06-12 18:22:31 -06:00
|
|
|
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.
|
2011-11-01 20:05:34 -06:00
|
|
|
func goLookupHost(name string) (addrs []string, err error) {
|
2011-06-12 18:22:31 -06:00
|
|
|
// Use entries from /etc/hosts if they match.
|
|
|
|
addrs = lookupStaticHost(name)
|
|
|
|
if len(addrs) > 0 {
|
|
|
|
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.
|
2011-11-01 20:05:34 -06:00
|
|
|
func goLookupIP(name string) (addrs []IP, err error) {
|
2011-09-19 09:50:31 -06:00
|
|
|
// 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
|
|
|
|
}
|
|
|
|
}
|
2011-06-12 18:22:31 -06:00
|
|
|
var records []dnsRR
|
|
|
|
var cname string
|
2012-06-25 15:32:39 -06:00
|
|
|
var err4, err6 error
|
|
|
|
cname, records, err4 = lookup(name, dnsTypeA)
|
2011-06-12 18:22:31 -06:00
|
|
|
addrs = convertRR_A(records)
|
|
|
|
if cname != "" {
|
|
|
|
name = cname
|
|
|
|
}
|
2012-06-25 15:32:39 -06:00
|
|
|
_, records, err6 = lookup(name, dnsTypeAAAA)
|
|
|
|
if err4 != nil && err6 == nil {
|
|
|
|
// Ignore A error because AAAA lookup succeeded.
|
|
|
|
err4 = nil
|
2011-06-12 18:22:31 -06:00
|
|
|
}
|
2012-06-25 15:32:39 -06:00
|
|
|
if err6 != nil && len(addrs) > 0 {
|
|
|
|
// Ignore AAAA error because A lookup succeeded.
|
|
|
|
err6 = nil
|
2011-06-12 18:22:31 -06:00
|
|
|
}
|
2012-06-25 15:32:39 -06:00
|
|
|
if err4 != nil {
|
|
|
|
return nil, err4
|
|
|
|
}
|
|
|
|
if err6 != nil {
|
|
|
|
return nil, err6
|
|
|
|
}
|
|
|
|
|
2011-06-12 18:22:31 -06:00
|
|
|
addrs = append(addrs, convertRR_AAAA(records)...)
|
2012-06-25 15:32:39 -06:00
|
|
|
return addrs, nil
|
2011-06-12 18:22:31 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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.
|
2011-11-01 20:05:34 -06:00
|
|
|
func goLookupCNAME(name string) (cname string, err error) {
|
2011-06-12 18:22:31 -06:00
|
|
|
_, rr, err := lookup(name, dnsTypeCNAME)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
cname = rr[0].(*dnsRR_CNAME).Cname
|
|
|
|
return
|
|
|
|
}
|