libgo/go/net/dnsconfig_unix.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 //go:build aix || darwin || dragonfly || freebsd || hurd || linux || netbsd || openbsd || solaris
   6
   7 // Read system DNS config from /etc/resolv.conf
   8
   9 package net
  10
  11 import (
  12         "internal/bytealg"
  13         "os"
  14         "sync/atomic"
  15         "time"
  16 )
  17
  18 var (
  19         defaultNS   = []string{"127.0.0.1:53", "[::1]:53"}
  20         getHostname = os.Hostname // variable for testing
  21 )
  22
  23 type dnsConfig struct {
  24         servers       []string      // server addresses (in host:port form) to use
  25         search        []string      // rooted suffixes to append to local name
  26         ndots         int           // number of dots in name to trigger absolute lookup
  27         timeout       time.Duration // wait before giving up on a query, including retries
  28         attempts      int           // lost packets before giving up on server
  29         rotate        bool          // round robin among servers
  30         unknownOpt    bool          // anything unknown was encountered
  31         lookup        []string      // OpenBSD top-level database "lookup" order
  32         err           error         // any error that occurs during open of resolv.conf
  33         mtime         time.Time     // time of resolv.conf modification
  34         soffset       uint32        // used by serverOffset
  35         singleRequest bool          // use sequential A and AAAA queries instead of parallel queries
  36         useTCP        bool          // force usage of TCP for DNS resolutions
  37 }
  38
  39 // See resolv.conf(5) on a Linux machine.
  40 func dnsReadConfig(filename string) *dnsConfig {
  41         conf := &dnsConfig{
  42                 ndots:    1,
  43                 timeout:  5 * time.Second,
  44                 attempts: 2,
  45         }
  46         file, err := open(filename)
  47         if err != nil {
  48                 conf.servers = defaultNS
  49                 conf.search = dnsDefaultSearch()
  50                 conf.err = err
  51                 return conf
  52         }
  53         defer file.close()
  54         if fi, err := file.file.Stat(); err == nil {
  55                 conf.mtime = fi.ModTime()
  56         } else {
  57                 conf.servers = defaultNS
  58                 conf.search = dnsDefaultSearch()
  59                 conf.err = err
  60                 return conf
  61         }
  62         for line, ok := file.readLine(); ok; line, ok = file.readLine() {
  63                 if len(line) > 0 && (line[0] == ';' || line[0] == '#') {
  64                         // comment.
  65                         continue
  66                 }
  67                 f := getFields(line)
  68                 if len(f) < 1 {
  69                         continue
  70                 }
  71                 switch f[0] {
  72                 case "nameserver": // add one name server
  73                         if len(f) > 1 && len(conf.servers) < 3 { // small, but the standard limit
  74                                 // One more check: make sure server name is
  75                                 // just an IP address. Otherwise we need DNS
  76                                 // to look it up.
  77                                 if parseIPv4(f[1]) != nil {
  78                                         conf.servers = append(conf.servers, JoinHostPort(f[1], "53"))
  79                                 } else if ip, _ := parseIPv6Zone(f[1]); ip != nil {
  80                                         conf.servers = append(conf.servers, JoinHostPort(f[1], "53"))
  81                                 }
  82                         }
  83
  84                 case "domain": // set search path to just this domain
  85                         if len(f) > 1 {
  86                                 conf.search = []string{ensureRooted(f[1])}
  87                         }
  88
  89                 case "search": // set search path to given servers
  90                         conf.search = make([]string, len(f)-1)
  91                         for i := 0; i < len(conf.search); i++ {
  92                                 conf.search[i] = ensureRooted(f[i+1])
  93                         }
  94
  95                 case "options": // magic options
  96                         for _, s := range f[1:] {
  97                                 switch {
  98                                 case hasPrefix(s, "ndots:"):
  99                                         n, _, _ := dtoi(s[6:])
 100                                         if n < 0 {
 101                                                 n = 0
 102                                         } else if n > 15 {
 103                                                 n = 15
 104                                         }
 105                                         conf.ndots = n
 106                                 case hasPrefix(s, "timeout:"):
 107                                         n, _, _ := dtoi(s[8:])
 108                                         if n < 1 {
 109                                                 n = 1
 110                                         }
 111                                         conf.timeout = time.Duration(n) * time.Second
 112                                 case hasPrefix(s, "attempts:"):
 113                                         n, _, _ := dtoi(s[9:])
 114                                         if n < 1 {
 115                                                 n = 1
 116                                         }
 117                                         conf.attempts = n
 118                                 case s == "rotate":
 119                                         conf.rotate = true
 120                                 case s == "single-request" || s == "single-request-reopen":
 121                                         // Linux option:
 122                                         // http://man7.org/linux/man-pages/man5/resolv.conf.5.html
 123                                         // "By default, glibc performs IPv4 and IPv6 lookups in parallel [...]
 124                                         //  This option disables the behavior and makes glibc
 125                                         //  perform the IPv6 and IPv4 requests sequentially."
 126                                         conf.singleRequest = true
 127                                 case s == "use-vc" || s == "usevc" || s == "tcp":
 128                                         // Linux (use-vc), FreeBSD (usevc) and OpenBSD (tcp) option:
 129                                         // http://man7.org/linux/man-pages/man5/resolv.conf.5.html
 130                                         // "Sets RES_USEVC in _res.options.
 131                                         //  This option forces the use of TCP for DNS resolutions."
 132                                         // https://www.freebsd.org/cgi/man.cgi?query=resolv.conf&sektion=5&manpath=freebsd-release-ports
 133                                         // https://man.openbsd.org/resolv.conf.5
 134                                         conf.useTCP = true
 135                                 default:
 136                                         conf.unknownOpt = true
 137                                 }
 138                         }
 139
 140                 case "lookup":
 141                         // OpenBSD option:
 142                         // https://www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man5/resolv.conf.5
 143                         // "the legal space-separated values are: bind, file, yp"
 144                         conf.lookup = f[1:]
 145
 146                 default:
 147                         conf.unknownOpt = true
 148                 }
 149         }
 150         if len(conf.servers) == 0 {
 151                 conf.servers = defaultNS
 152         }
 153         if len(conf.search) == 0 {
 154                 conf.search = dnsDefaultSearch()
 155         }
 156         return conf
 157 }
 158
 159 // serverOffset returns an offset that can be used to determine
 160 // indices of servers in c.servers when making queries.
 161 // When the rotate option is enabled, this offset increases.
 162 // Otherwise it is always 0.
 163 func (c *dnsConfig) serverOffset() uint32 {
 164         if c.rotate {
 165                 return atomic.AddUint32(&c.soffset, 1) - 1 // return 0 to start
 166         }
 167         return 0
 168 }
 169
 170 func dnsDefaultSearch() []string {
 171         hn, err := getHostname()
 172         if err != nil {
 173                 // best effort
 174                 return nil
 175         }
 176         if i := bytealg.IndexByteString(hn, '.'); i >= 0 && i < len(hn)-1 {
 177                 return []string{ensureRooted(hn[i+1:])}
 178         }
 179         return nil
 180 }
 181
 182 func hasPrefix(s, prefix string) bool {
 183         return len(s) >= len(prefix) && s[:len(prefix)] == prefix
 184 }
 185
 186 func ensureRooted(s string) string {
 187         if len(s) > 0 && s[len(s)-1] == '.' {
 188                 return s
 189         }
 190         return s + "."
 191 }