net: rearrange source files so we could run more tests on windows

R=rsc
CC=golang-dev
https://golang.org/cl/4603043

src/pkg/net/Makefile

@@ -7,6 +7,7 @@ include ../../Make.inc
 TARG=net
 GOFILES=\
 	dial.go\
+	dnsclient.go\
 	dnsmsg.go\
 	fd_$(GOOS).go\
 	hosts.go\
@@ -14,7 +15,6 @@ GOFILES=\
 	ip.go\
 	ipsock.go\
 	iprawsock.go\
-	lookup.go\
 	net.go\
 	parse.go\
 	pipe.go\
@@ -24,11 +24,12 @@ GOFILES=\
 	unixsock.go\
 
 GOFILES_freebsd=\
-	dnsclient.go\
+	dnsclient_unix.go\
 	dnsconfig.go\
 	fd.go\
 	file.go\
 	interface_bsd.go\
+	lookup_unix.go\
 	newpollserver.go\
 	port.go\
 	sendfile_stub.go\
@@ -39,11 +40,12 @@ CGOFILES_freebsd=\
 	cgo_unix.go\
 
 GOFILES_darwin=\
-	dnsclient.go\
+	dnsclient_unix.go\
 	dnsconfig.go\
 	fd.go\
 	file.go\
 	interface_bsd.go\
+	lookup_unix.go\
 	newpollserver.go\
 	port.go\
 	sendfile_stub.go\
@@ -54,11 +56,12 @@ CGOFILES_darwin=\
 	cgo_unix.go\
 
 GOFILES_linux=\
-	dnsclient.go\
+	dnsclient_unix.go\
 	dnsconfig.go\
 	fd.go\
 	file.go\
 	interface_linux.go\
+	lookup_unix.go\
 	newpollserver.go\
 	port.go\
 	sendfile_linux.go\
@@ -66,6 +69,7 @@ GOFILES_linux=\
 
 GOFILES_plan9=\
 	interface_stub.go\
+	lookup_unix.go\
 	sendfile_stub.go\
 
 ifeq ($(GOARCH),arm)
@@ -78,10 +82,9 @@ CGOFILES_linux=\
 endif
 
 GOFILES_windows=\
-	cgo_stub.go\
 	file_windows.go\
 	interface_stub.go\
-	resolv_windows.go\
+	lookup_windows.go\
 	sendfile_windows.go\
 	sock_windows.go\
 

src/pkg/net/dnsclient_unix.go

+// 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.
+
+// 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 (
+	"os"
+	"rand"
+	"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, os.Error) {
+	if len(name) >= 256 {
+		return nil, &DNSError{Error: "name too long", Name: name}
+	}
+	out := new(dnsMsg)
+	out.id = uint16(rand.Int()) ^ uint16(time.Nanoseconds())
+	out.question = []dnsQuestion{
+		{name, qtype, dnsClassINET},
+	}
+	out.recursion_desired = true
+	msg, ok := out.Pack()
+	if !ok {
+		return nil, &DNSError{Error: "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
+		}
+
+		c.SetReadTimeout(int64(cfg.timeout) * 1e9) // nanoseconds
+
+		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{Error: "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 os.Error) {
+	if len(cfg.servers) == 0 {
+		return "", nil, &DNSError{Error: "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).Error == 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, 16)
+		copy(a, rr.(*dnsRR_AAAA).AAAA[:])
+		addrs[i] = a
+	}
+	return addrs
+}
+
+var cfg *dnsConfig
+var dnserr os.Error
+
+func loadConfig() { cfg, dnserr = dnsReadConfig() }
+
+var onceLoadConfig sync.Once
+
+func lookup(name string, qtype uint16) (cname string, addrs []dnsRR, err os.Error) {
+	if !isDomainName(name) {
+		return name, nil, &DNSError{Error: "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 os.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 os.Error) {
+	onceLoadConfig.Do(loadConfig)
+	if dnserr != nil || cfg == nil {
+		err = dnserr
+		return
+	}
+	var records []dnsRR
+	var cname string
+	cname, records, err = lookup(name, dnsTypeA)
+	if err != nil {
+		return
+	}
+	addrs = convertRR_A(records)
+	if cname != "" {
+		name = cname
+	}
+	_, records, err = lookup(name, dnsTypeAAAA)
+	if err != nil && len(addrs) > 0 {
+		// Ignore error because A lookup succeeded.
+		err = nil
+	}
+	if err != nil {
+		return
+	}
+	addrs = append(addrs, convertRR_AAAA(records)...)
+	return
+}
+
+// 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 os.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
+}

src/pkg/net/dnsmsg_test.go

@@ -6,14 +6,10 @@ package net
 
 import (
 	"encoding/hex"
-	"runtime"
 	"testing"
 )
 
 func TestDNSParseSRVReply(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		return
-	}
 	data, err := hex.DecodeString(dnsSRVReply)
 	if err != nil {
 		t.Fatal(err)
@@ -45,9 +41,6 @@ func TestDNSParseSRVReply(t *testing.T) {
 }
 
 func TestDNSParseCorruptSRVReply(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		return
-	}
 	data, err := hex.DecodeString(dnsSRVCorruptReply)
 	if err != nil {
 		t.Fatal(err)

src/pkg/net/dnsname_test.go

@@ -6,7 +6,6 @@ package net
 
 import (
 	"testing"
-	"runtime"
 )
 
 type testCase struct {
@@ -55,9 +54,6 @@ func getTestCases(ch chan<- testCase) {
 }
 
 func TestDNSNames(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		return
-	}
 	ch := make(chan testCase)
 	go getTestCases(ch)
 	for tc := range ch {

src/pkg/net/lookup.go → src/pkg/net/lookup_unix.go

@@ -6,6 +6,8 @@ package net
 
 import (
 	"os"
+	"rand"
+	"sort"
 )
 
 // LookupHost looks up the given host using the local resolver.
@@ -48,3 +50,77 @@ func LookupCNAME(name string) (cname string, err os.Error) {
 	}
 	return
 }
+
+// LookupSRV tries to resolve an SRV query of the given service,
+// protocol, and domain name, as specified in RFC 2782. In most cases
+// the proto argument can be the same as the corresponding
+// Addr.Network(). The returned records are sorted by priority 
+// and randomized by weight within a priority.
+func LookupSRV(service, proto, name string) (cname string, addrs []*SRV, err os.Error) {
+	target := "_" + service + "._" + proto + "." + name
+	var records []dnsRR
+	cname, records, err = lookup(target, dnsTypeSRV)
+	if err != nil {
+		return
+	}
+	addrs = make([]*SRV, len(records))
+	for i, rr := range records {
+		r := rr.(*dnsRR_SRV)
+		addrs[i] = &SRV{r.Target, r.Port, r.Priority, r.Weight}
+	}
+	sort.Sort(byPriorityWeight(addrs))
+	i := 0
+	for j := 1; j < len(addrs); j++ {
+		if addrs[i].Priority != addrs[j].Priority {
+			shuffleSRVByWeight(addrs[i:j])
+			i = j
+		}
+	}
+	shuffleSRVByWeight(addrs[i:len(addrs)])
+	return
+}
+
+// LookupMX returns the DNS MX records for the given domain name sorted by preference.
+func LookupMX(name string) (mx []*MX, err os.Error) {
+	_, rr, err := lookup(name, dnsTypeMX)
+	if err != nil {
+		return
+	}
+	mx = make([]*MX, len(rr))
+	for i := range rr {
+		r := rr[i].(*dnsRR_MX)
+		mx[i] = &MX{r.Mx, r.Pref}
+	}
+	// Shuffle the records to match RFC 5321 when sorted
+	for i := range mx {
+		j := rand.Intn(i + 1)
+		mx[i], mx[j] = mx[j], mx[i]
+	}
+	sort.Sort(byPref(mx))
+	return
+}
+
+// LookupAddr performs a reverse lookup for the given address, returning a list
+// of names mapping to that address.
+func LookupAddr(addr string) (name []string, err os.Error) {
+	name = lookupStaticAddr(addr)
+	if len(name) > 0 {
+		return
+	}
+	var arpa string
+	arpa, err = reverseaddr(addr)
+	if err != nil {
+		return
+	}
+	var records []dnsRR
+	_, records, err = lookup(arpa, dnsTypePTR)
+	if err != nil {
+		return
+	}
+	name = make([]string, len(records))
+	for i := range records {
+		r := records[i].(*dnsRR_PTR)
+		name[i] = r.Ptr
+	}
+	return
+}

src/pkg/net/resolv_windows.go → src/pkg/net/lookup_windows.go

@@ -14,8 +14,8 @@ import (
 var hostentLock sync.Mutex
 var serventLock sync.Mutex
 
-func goLookupHost(name string) (addrs []string, err os.Error) {
-	ips, err := goLookupIP(name)
+func LookupHost(name string) (addrs []string, err os.Error) {
+	ips, err := LookupIP(name)
 	if err != nil {
 		return
 	}
@@ -26,7 +26,7 @@ func goLookupHost(name string) (addrs []string, err os.Error) {
 	return
 }
 
-func goLookupIP(name string) (addrs []IP, err os.Error) {
+func LookupIP(name string) (addrs []IP, err os.Error) {
 	hostentLock.Lock()
 	defer hostentLock.Unlock()
 	h, e := syscall.GetHostByName(name)
@@ -47,7 +47,23 @@ func goLookupIP(name string) (addrs []IP, err os.Error) {
 	return addrs, nil
 }
 
-func goLookupCNAME(name string) (cname string, err os.Error) {
+func LookupPort(network, service string) (port int, err os.Error) {
+	switch network {
+	case "tcp4", "tcp6":
+		network = "tcp"
+	case "udp4", "udp6":
+		network = "udp"
+	}
+	serventLock.Lock()
+	defer serventLock.Unlock()
+	s, e := syscall.GetServByName(service, network)
+	if e != 0 {
+		return 0, os.NewSyscallError("GetServByName", e)
+	}
+	return int(syscall.Ntohs(s.Port)), nil
+}
+
+func LookupCNAME(name string) (cname string, err os.Error) {
 	var r *syscall.DNSRecord
 	e := syscall.DnsQuery(name, syscall.DNS_TYPE_CNAME, 0, nil, &r, nil)
 	if int(e) != 0 {
@@ -61,13 +77,6 @@ func goLookupCNAME(name string) (cname string, err os.Error) {
 	return
 }
 
-type SRV struct {
-	Target   string
-	Port     uint16
-	Priority uint16
-	Weight   uint16
-}
-
 func LookupSRV(service, proto, name string) (cname string, addrs []*SRV, err os.Error) {
 	var r *syscall.DNSRecord
 	target := "_" + service + "._" + proto + "." + name
@@ -87,55 +96,12 @@ func LookupSRV(service, proto, name string) (cname string, addrs []*SRV, err os.
 	return name, addrs, nil
 }
 
-func goLookupPort(network, service string) (port int, err os.Error) {
-	switch network {
-	case "tcp4", "tcp6":
-		network = "tcp"
-	case "udp4", "udp6":
-		network = "udp"
-	}
-	serventLock.Lock()
-	defer serventLock.Unlock()
-	s, e := syscall.GetServByName(service, network)
-	if e != 0 {
-		return 0, os.NewSyscallError("GetServByName", e)
-	}
-	return int(syscall.Ntohs(s.Port)), nil
-}
+// TODO(brainman): implement LookupMX and LookupAddr.
 
-// TODO(brainman): Following code is only to get tests running.
-
-func isDomainName(s string) bool {
-	panic("unimplemented")
-}
-
-func reverseaddr(addr string) (arpa string, err os.Error) {
-	panic("unimplemented")
-}
-
-func answer(name, server string, dns *dnsMsg, qtype uint16) (cname string, addrs []dnsRR, err os.Error) {
-	panic("unimplemented")
+func LookupMX(name string) (mx []*MX, err os.Error) {
+	return nil, os.NewSyscallError("LookupMX", syscall.EWINDOWS)
 }
 
-// DNSError represents a DNS lookup error.
-type DNSError struct {
-	Error     string // description of the error
-	Name      string // name looked for
-	Server    string // server used
-	IsTimeout bool
+func LookupAddr(addr string) (name []string, err os.Error) {
+	return nil, os.NewSyscallError("LookupAddr", syscall.EWINDOWS)
 }
-
-func (e *DNSError) String() string {
-	if e == nil {
-		return "<nil>"
-	}
-	s := "lookup " + e.Name
-	if e.Server != "" {
-		s += " on " + e.Server
-	}
-	s += ": " + e.Error
-	return s
-}
-
-func (e *DNSError) Timeout() bool   { return e.IsTimeout }
-func (e *DNSError) Temporary() bool { return e.IsTimeout }

src/pkg/net/net_test.go

@@ -7,7 +7,6 @@ package net
 import (
 	"flag"
 	"regexp"
-	"runtime"
 	"testing"
 )
 
@@ -103,9 +102,6 @@ var revAddrTests = []struct {
 }
 
 func TestReverseAddress(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		return
-	}
 	for i, tt := range revAddrTests {
 		a, e := reverseaddr(tt.Addr)
 		if len(tt.ErrPrefix) > 0 && e == nil {