github.com/dorkamotorka/go/src@v0.0.0-20230614113921-187095f0e316/net/dnsclient.go (about) 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 }