...
Run Format

Source file src/net/dnsclient.go

     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	package net
     6	
     7	import (
     8		"math/rand"
     9		"sort"
    10	)
    11	
    12	// reverseaddr returns the in-addr.arpa. or ip6.arpa. hostname of the IP
    13	// address addr suitable for rDNS (PTR) record lookup or an error if it fails
    14	// to parse the IP address.
    15	func reverseaddr(addr string) (arpa string, err error) {
    16		ip := ParseIP(addr)
    17		if ip == nil {
    18			return "", &DNSError{Err: "unrecognized address", Name: addr}
    19		}
    20		if ip.To4() != nil {
    21			return uitoa(uint(ip[15])) + "." + uitoa(uint(ip[14])) + "." + uitoa(uint(ip[13])) + "." + uitoa(uint(ip[12])) + ".in-addr.arpa.", nil
    22		}
    23		// Must be IPv6
    24		buf := make([]byte, 0, len(ip)*4+len("ip6.arpa."))
    25		// Add it, in reverse, to the buffer
    26		for i := len(ip) - 1; i >= 0; i-- {
    27			v := ip[i]
    28			buf = append(buf, hexDigit[v&0xF])
    29			buf = append(buf, '.')
    30			buf = append(buf, hexDigit[v>>4])
    31			buf = append(buf, '.')
    32		}
    33		// Append "ip6.arpa." and return (buf already has the final .)
    34		buf = append(buf, "ip6.arpa."...)
    35		return string(buf), nil
    36	}
    37	
    38	// Find answer for name in dns message.
    39	// On return, if err == nil, addrs != nil.
    40	func answer(name, server string, dns *dnsMsg, qtype uint16) (cname string, addrs []dnsRR, err error) {
    41		addrs = make([]dnsRR, 0, len(dns.answer))
    42	
    43		if dns.rcode == dnsRcodeNameError {
    44			return "", nil, &DNSError{Err: errNoSuchHost.Error(), Name: name, Server: server}
    45		}
    46		if dns.rcode != dnsRcodeSuccess {
    47			// None of the error codes make sense
    48			// for the query we sent. If we didn't get
    49			// a name error and we didn't get success,
    50			// the server is behaving incorrectly or
    51			// having temporary trouble.
    52			err := &DNSError{Err: "server misbehaving", Name: name, Server: server}
    53			if dns.rcode == dnsRcodeServerFailure {
    54				err.IsTemporary = true
    55			}
    56			return "", nil, err
    57		}
    58	
    59		// Look for the name.
    60		// Presotto says it's okay to assume that servers listed in
    61		// /etc/resolv.conf are recursive resolvers.
    62		// We asked for recursion, so it should have included
    63		// all the answers we need in this one packet.
    64	Cname:
    65		for cnameloop := 0; cnameloop < 10; cnameloop++ {
    66			addrs = addrs[0:0]
    67			for _, rr := range dns.answer {
    68				if _, justHeader := rr.(*dnsRR_Header); justHeader {
    69					// Corrupt record: we only have a
    70					// header. That header might say it's
    71					// of type qtype, but we don't
    72					// actually have it. Skip.
    73					continue
    74				}
    75				h := rr.Header()
    76				if h.Class == dnsClassINET && equalASCIILabel(h.Name, name) {
    77					switch h.Rrtype {
    78					case qtype:
    79						addrs = append(addrs, rr)
    80					case dnsTypeCNAME:
    81						// redirect to cname
    82						name = rr.(*dnsRR_CNAME).Cname
    83						continue Cname
    84					}
    85				}
    86			}
    87			if len(addrs) == 0 {
    88				return "", nil, &DNSError{Err: errNoSuchHost.Error(), Name: name, Server: server}
    89			}
    90			return name, addrs, nil
    91		}
    92	
    93		return "", nil, &DNSError{Err: "too many redirects", Name: name, Server: server}
    94	}
    95	
    96	func equalASCIILabel(x, y string) bool {
    97		if len(x) != len(y) {
    98			return false
    99		}
   100		for i := 0; i < len(x); i++ {
   101			a := x[i]
   102			b := y[i]
   103			if 'A' <= a && a <= 'Z' {
   104				a += 0x20
   105			}
   106			if 'A' <= b && b <= 'Z' {
   107				b += 0x20
   108			}
   109			if a != b {
   110				return false
   111			}
   112		}
   113		return true
   114	}
   115	
   116	// isDomainName checks if a string is a presentation-format domain name
   117	// (currently restricted to hostname-compatible "preferred name" LDH labels and
   118	// SRV-like "underscore labels"; see golang.org/issue/12421).
   119	func isDomainName(s string) bool {
   120		// See RFC 1035, RFC 3696.
   121		// Presentation format has dots before every label except the first, and the
   122		// terminal empty label is optional here because we assume fully-qualified
   123		// (absolute) input. We must therefore reserve space for the first and last
   124		// labels' length octets in wire format, where they are necessary and the
   125		// maximum total length is 255.
   126		// So our _effective_ maximum is 253, but 254 is not rejected if the last
   127		// character is a dot.
   128		l := len(s)
   129		if l == 0 || l > 254 || l == 254 && s[l-1] != '.' {
   130			return false
   131		}
   132	
   133		last := byte('.')
   134		ok := false // Ok once we've seen a letter.
   135		partlen := 0
   136		for i := 0; i < len(s); i++ {
   137			c := s[i]
   138			switch {
   139			default:
   140				return false
   141			case 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || c == '_':
   142				ok = true
   143				partlen++
   144			case '0' <= c && c <= '9':
   145				// fine
   146				partlen++
   147			case c == '-':
   148				// Byte before dash cannot be dot.
   149				if last == '.' {
   150					return false
   151				}
   152				partlen++
   153			case c == '.':
   154				// Byte before dot cannot be dot, dash.
   155				if last == '.' || last == '-' {
   156					return false
   157				}
   158				if partlen > 63 || partlen == 0 {
   159					return false
   160				}
   161				partlen = 0
   162			}
   163			last = c
   164		}
   165		if last == '-' || partlen > 63 {
   166			return false
   167		}
   168	
   169		return ok
   170	}
   171	
   172	// absDomainName returns an absolute domain name which ends with a
   173	// trailing dot to match pure Go reverse resolver and all other lookup
   174	// routines.
   175	// See golang.org/issue/12189.
   176	// But we don't want to add dots for local names from /etc/hosts.
   177	// It's hard to tell so we settle on the heuristic that names without dots
   178	// (like "localhost" or "myhost") do not get trailing dots, but any other
   179	// names do.
   180	func absDomainName(b []byte) string {
   181		hasDots := false
   182		for _, x := range b {
   183			if x == '.' {
   184				hasDots = true
   185				break
   186			}
   187		}
   188		if hasDots && b[len(b)-1] != '.' {
   189			b = append(b, '.')
   190		}
   191		return string(b)
   192	}
   193	
   194	// An SRV represents a single DNS SRV record.
   195	type SRV struct {
   196		Target   string
   197		Port     uint16
   198		Priority uint16
   199		Weight   uint16
   200	}
   201	
   202	// byPriorityWeight sorts SRV records by ascending priority and weight.
   203	type byPriorityWeight []*SRV
   204	
   205	func (s byPriorityWeight) Len() int { return len(s) }
   206	func (s byPriorityWeight) Less(i, j int) bool {
   207		return s[i].Priority < s[j].Priority || (s[i].Priority == s[j].Priority && s[i].Weight < s[j].Weight)
   208	}
   209	func (s byPriorityWeight) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
   210	
   211	// shuffleByWeight shuffles SRV records by weight using the algorithm
   212	// described in RFC 2782.
   213	func (addrs byPriorityWeight) shuffleByWeight() {
   214		sum := 0
   215		for _, addr := range addrs {
   216			sum += int(addr.Weight)
   217		}
   218		for sum > 0 && len(addrs) > 1 {
   219			s := 0
   220			n := rand.Intn(sum)
   221			for i := range addrs {
   222				s += int(addrs[i].Weight)
   223				if s > n {
   224					if i > 0 {
   225						addrs[0], addrs[i] = addrs[i], addrs[0]
   226					}
   227					break
   228				}
   229			}
   230			sum -= int(addrs[0].Weight)
   231			addrs = addrs[1:]
   232		}
   233	}
   234	
   235	// sort reorders SRV records as specified in RFC 2782.
   236	func (addrs byPriorityWeight) sort() {
   237		sort.Sort(addrs)
   238		i := 0
   239		for j := 1; j < len(addrs); j++ {
   240			if addrs[i].Priority != addrs[j].Priority {
   241				addrs[i:j].shuffleByWeight()
   242				i = j
   243			}
   244		}
   245		addrs[i:].shuffleByWeight()
   246	}
   247	
   248	// An MX represents a single DNS MX record.
   249	type MX struct {
   250		Host string
   251		Pref uint16
   252	}
   253	
   254	// byPref implements sort.Interface to sort MX records by preference
   255	type byPref []*MX
   256	
   257	func (s byPref) Len() int           { return len(s) }
   258	func (s byPref) Less(i, j int) bool { return s[i].Pref < s[j].Pref }
   259	func (s byPref) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
   260	
   261	// sort reorders MX records as specified in RFC 5321.
   262	func (s byPref) sort() {
   263		for i := range s {
   264			j := rand.Intn(i + 1)
   265			s[i], s[j] = s[j], s[i]
   266		}
   267		sort.Sort(s)
   268	}
   269	
   270	// An NS represents a single DNS NS record.
   271	type NS struct {
   272		Host string
   273	}
   274	

View as plain text