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  	"internal/bytealg"
     9  	"internal/itoa"
    10  	"sort"
    11  
    12  	"golang.org/x/net/dns/dnsmessage"
    13  )
    14  
    15  // provided by runtime
    16  func fastrandu() uint
    17  
    18  func randInt() int {
    19  	return int(fastrandu() >> 1) // clear sign bit
    20  }
    21  
    22  func randIntn(n int) int {
    23  	return randInt() % n
    24  }
    25  
    26  // reverseaddr returns the in-addr.arpa. or ip6.arpa. hostname of the IP
    27  // address addr suitable for rDNS (PTR) record lookup or an error if it fails
    28  // to parse the IP address.
    29  func reverseaddr(addr string) (arpa string, err error) {
    30  	ip := ParseIP(addr)
    31  	if ip == nil {
    32  		return "", &DNSError{Err: "unrecognized address", Name: addr}
    33  	}
    34  	if ip.To4() != nil {
    35  		return itoa.Uitoa(uint(ip[15])) + "." + itoa.Uitoa(uint(ip[14])) + "." + itoa.Uitoa(uint(ip[13])) + "." + itoa.Uitoa(uint(ip[12])) + ".in-addr.arpa.", nil
    36  	}
    37  	// Must be IPv6
    38  	buf := make([]byte, 0, len(ip)*4+len("ip6.arpa."))
    39  	// Add it, in reverse, to the buffer
    40  	for i := len(ip) - 1; i >= 0; i-- {
    41  		v := ip[i]
    42  		buf = append(buf, hexDigit[v&0xF],
    43  			'.',
    44  			hexDigit[v>>4],
    45  			'.')
    46  	}
    47  	// Append "ip6.arpa." and return (buf already has the final .)
    48  	buf = append(buf, "ip6.arpa."...)
    49  	return string(buf), nil
    50  }
    51  
    52  func equalASCIIName(x, y dnsmessage.Name) bool {
    53  	if x.Length != y.Length {
    54  		return false
    55  	}
    56  	for i := 0; i < int(x.Length); i++ {
    57  		a := x.Data[i]
    58  		b := y.Data[i]
    59  		if 'A' <= a && a <= 'Z' {
    60  			a += 0x20
    61  		}
    62  		if 'A' <= b && b <= 'Z' {
    63  			b += 0x20
    64  		}
    65  		if a != b {
    66  			return false
    67  		}
    68  	}
    69  	return true
    70  }
    71  
    72  // isDomainName checks if a string is a presentation-format domain name
    73  // (currently restricted to hostname-compatible "preferred name" LDH labels and
    74  // SRV-like "underscore labels"; see golang.org/issue/12421).
    75  func isDomainName(s string) bool {
    76  	// The root domain name is valid. See golang.org/issue/45715.
    77  	if s == "." {
    78  		return true
    79  	}
    80  
    81  	// See RFC 1035, RFC 3696.
    82  	// Presentation format has dots before every label except the first, and the
    83  	// terminal empty label is optional here because we assume fully-qualified
    84  	// (absolute) input. We must therefore reserve space for the first and last
    85  	// labels' length octets in wire format, where they are necessary and the
    86  	// maximum total length is 255.
    87  	// So our _effective_ maximum is 253, but 254 is not rejected if the last
    88  	// character is a dot.
    89  	l := len(s)
    90  	if l == 0 || l > 254 || l == 254 && s[l-1] != '.' {
    91  		return false
    92  	}
    93  
    94  	last := byte('.')
    95  	nonNumeric := false // true once we've seen a letter or hyphen
    96  	partlen := 0
    97  	for i := 0; i < len(s); i++ {
    98  		c := s[i]
    99  		switch {
   100  		default:
   101  			return false
   102  		case 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || c == '_':
   103  			nonNumeric = true
   104  			partlen++
   105  		case '0' <= c && c <= '9':
   106  			// fine
   107  			partlen++
   108  		case c == '-':
   109  			// Byte before dash cannot be dot.
   110  			if last == '.' {
   111  				return false
   112  			}
   113  			partlen++
   114  			nonNumeric = true
   115  		case c == '.':
   116  			// Byte before dot cannot be dot, dash.
   117  			if last == '.' || last == '-' {
   118  				return false
   119  			}
   120  			if partlen > 63 || partlen == 0 {
   121  				return false
   122  			}
   123  			partlen = 0
   124  		}
   125  		last = c
   126  	}
   127  	if last == '-' || partlen > 63 {
   128  		return false
   129  	}
   130  
   131  	return nonNumeric
   132  }
   133  
   134  // absDomainName returns an absolute domain name which ends with a
   135  // trailing dot to match pure Go reverse resolver and all other lookup
   136  // routines.
   137  // See golang.org/issue/12189.
   138  // But we don't want to add dots for local names from /etc/hosts.
   139  // It's hard to tell so we settle on the heuristic that names without dots
   140  // (like "localhost" or "myhost") do not get trailing dots, but any other
   141  // names do.
   142  func absDomainName(s string) string {
   143  	if bytealg.IndexByteString(s, '.') != -1 && s[len(s)-1] != '.' {
   144  		s += "."
   145  	}
   146  	return s
   147  }
   148  
   149  // An SRV represents a single DNS SRV record.
   150  type SRV struct {
   151  	Target   string
   152  	Port     uint16
   153  	Priority uint16
   154  	Weight   uint16
   155  }
   156  
   157  // byPriorityWeight sorts SRV records by ascending priority and weight.
   158  type byPriorityWeight []*SRV
   159  
   160  func (s byPriorityWeight) Len() int { return len(s) }
   161  func (s byPriorityWeight) Less(i, j int) bool {
   162  	return s[i].Priority < s[j].Priority || (s[i].Priority == s[j].Priority && s[i].Weight < s[j].Weight)
   163  }
   164  func (s byPriorityWeight) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
   165  
   166  // shuffleByWeight shuffles SRV records by weight using the algorithm
   167  // described in RFC 2782.
   168  func (addrs byPriorityWeight) shuffleByWeight() {
   169  	sum := 0
   170  	for _, addr := range addrs {
   171  		sum += int(addr.Weight)
   172  	}
   173  	for sum > 0 && len(addrs) > 1 {
   174  		s := 0
   175  		n := randIntn(sum)
   176  		for i := range addrs {
   177  			s += int(addrs[i].Weight)
   178  			if s > n {
   179  				if i > 0 {
   180  					addrs[0], addrs[i] = addrs[i], addrs[0]
   181  				}
   182  				break
   183  			}
   184  		}
   185  		sum -= int(addrs[0].Weight)
   186  		addrs = addrs[1:]
   187  	}
   188  }
   189  
   190  // sort reorders SRV records as specified in RFC 2782.
   191  func (addrs byPriorityWeight) sort() {
   192  	sort.Sort(addrs)
   193  	i := 0
   194  	for j := 1; j < len(addrs); j++ {
   195  		if addrs[i].Priority != addrs[j].Priority {
   196  			addrs[i:j].shuffleByWeight()
   197  			i = j
   198  		}
   199  	}
   200  	addrs[i:].shuffleByWeight()
   201  }
   202  
   203  // An MX represents a single DNS MX record.
   204  type MX struct {
   205  	Host string
   206  	Pref uint16
   207  }
   208  
   209  // byPref implements sort.Interface to sort MX records by preference
   210  type byPref []*MX
   211  
   212  func (s byPref) Len() int           { return len(s) }
   213  func (s byPref) Less(i, j int) bool { return s[i].Pref < s[j].Pref }
   214  func (s byPref) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
   215  
   216  // sort reorders MX records as specified in RFC 5321.
   217  func (s byPref) sort() {
   218  	for i := range s {
   219  		j := randIntn(i + 1)
   220  		s[i], s[j] = s[j], s[i]
   221  	}
   222  	sort.Sort(s)
   223  }
   224  
   225  // An NS represents a single DNS NS record.
   226  type NS struct {
   227  	Host string
   228  }
   229
View as plain text