Source file src/net/lookup_unix.go

Documentation: net

     1  // Copyright 2011 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  // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
     6  
     7  package net
     8  
     9  import (
    10  	"context"
    11  	"internal/bytealg"
    12  	"sync"
    13  	"syscall"
    14  
    15  	"golang.org/x/net/dns/dnsmessage"
    16  )
    17  
    18  var onceReadProtocols sync.Once
    19  
    20  // readProtocols loads contents of /etc/protocols into protocols map
    21  // for quick access.
    22  func readProtocols() {
    23  	file, err := open("/etc/protocols")
    24  	if err != nil {
    25  		return
    26  	}
    27  	defer file.close()
    28  
    29  	for line, ok := file.readLine(); ok; line, ok = file.readLine() {
    30  		// tcp    6   TCP    # transmission control protocol
    31  		if i := bytealg.IndexByteString(line, '#'); i >= 0 {
    32  			line = line[0:i]
    33  		}
    34  		f := getFields(line)
    35  		if len(f) < 2 {
    36  			continue
    37  		}
    38  		if proto, _, ok := dtoi(f[1]); ok {
    39  			if _, ok := protocols[f[0]]; !ok {
    40  				protocols[f[0]] = proto
    41  			}
    42  			for _, alias := range f[2:] {
    43  				if _, ok := protocols[alias]; !ok {
    44  					protocols[alias] = proto
    45  				}
    46  			}
    47  		}
    48  	}
    49  }
    50  
    51  // lookupProtocol looks up IP protocol name in /etc/protocols and
    52  // returns correspondent protocol number.
    53  func lookupProtocol(_ context.Context, name string) (int, error) {
    54  	onceReadProtocols.Do(readProtocols)
    55  	return lookupProtocolMap(name)
    56  }
    57  
    58  func (r *Resolver) dial(ctx context.Context, network, server string) (Conn, error) {
    59  	// Calling Dial here is scary -- we have to be sure not to
    60  	// dial a name that will require a DNS lookup, or Dial will
    61  	// call back here to translate it. The DNS config parser has
    62  	// already checked that all the cfg.servers are IP
    63  	// addresses, which Dial will use without a DNS lookup.
    64  	var c Conn
    65  	var err error
    66  	if r != nil && r.Dial != nil {
    67  		c, err = r.Dial(ctx, network, server)
    68  	} else {
    69  		var d Dialer
    70  		c, err = d.DialContext(ctx, network, server)
    71  	}
    72  	if err != nil {
    73  		return nil, mapErr(err)
    74  	}
    75  	return c, nil
    76  }
    77  
    78  func (r *Resolver) lookupHost(ctx context.Context, host string) (addrs []string, err error) {
    79  	order := systemConf().hostLookupOrder(r, host)
    80  	if !r.preferGo() && order == hostLookupCgo {
    81  		if addrs, err, ok := cgoLookupHost(ctx, host); ok {
    82  			return addrs, err
    83  		}
    84  		// cgo not available (or netgo); fall back to Go's DNS resolver
    85  		order = hostLookupFilesDNS
    86  	}
    87  	return r.goLookupHostOrder(ctx, host, order)
    88  }
    89  
    90  func (r *Resolver) lookupIP(ctx context.Context, network, host string) (addrs []IPAddr, err error) {
    91  	if r.preferGo() {
    92  		return r.goLookupIP(ctx, host)
    93  	}
    94  	order := systemConf().hostLookupOrder(r, host)
    95  	if order == hostLookupCgo {
    96  		if addrs, err, ok := cgoLookupIP(ctx, network, host); ok {
    97  			return addrs, err
    98  		}
    99  		// cgo not available (or netgo); fall back to Go's DNS resolver
   100  		order = hostLookupFilesDNS
   101  	}
   102  	ips, _, err := r.goLookupIPCNAMEOrder(ctx, host, order)
   103  	return ips, err
   104  }
   105  
   106  func (r *Resolver) lookupPort(ctx context.Context, network, service string) (int, error) {
   107  	if !r.preferGo() && systemConf().canUseCgo() {
   108  		if port, err, ok := cgoLookupPort(ctx, network, service); ok {
   109  			if err != nil {
   110  				// Issue 18213: if cgo fails, first check to see whether we
   111  				// have the answer baked-in to the net package.
   112  				if port, err := goLookupPort(network, service); err == nil {
   113  					return port, nil
   114  				}
   115  			}
   116  			return port, err
   117  		}
   118  	}
   119  	return goLookupPort(network, service)
   120  }
   121  
   122  func (r *Resolver) lookupCNAME(ctx context.Context, name string) (string, error) {
   123  	if !r.preferGo() && systemConf().canUseCgo() {
   124  		if cname, err, ok := cgoLookupCNAME(ctx, name); ok {
   125  			return cname, err
   126  		}
   127  	}
   128  	return r.goLookupCNAME(ctx, name)
   129  }
   130  
   131  func (r *Resolver) lookupSRV(ctx context.Context, service, proto, name string) (string, []*SRV, error) {
   132  	var target string
   133  	if service == "" && proto == "" {
   134  		target = name
   135  	} else {
   136  		target = "_" + service + "._" + proto + "." + name
   137  	}
   138  	p, server, err := r.lookup(ctx, target, dnsmessage.TypeSRV)
   139  	if err != nil {
   140  		return "", nil, err
   141  	}
   142  	var srvs []*SRV
   143  	var cname dnsmessage.Name
   144  	for {
   145  		h, err := p.AnswerHeader()
   146  		if err == dnsmessage.ErrSectionDone {
   147  			break
   148  		}
   149  		if err != nil {
   150  			return "", nil, &DNSError{
   151  				Err:    "cannot unmarshal DNS message",
   152  				Name:   name,
   153  				Server: server,
   154  			}
   155  		}
   156  		if h.Type != dnsmessage.TypeSRV {
   157  			if err := p.SkipAnswer(); err != nil {
   158  				return "", nil, &DNSError{
   159  					Err:    "cannot unmarshal DNS message",
   160  					Name:   name,
   161  					Server: server,
   162  				}
   163  			}
   164  			continue
   165  		}
   166  		if cname.Length == 0 && h.Name.Length != 0 {
   167  			cname = h.Name
   168  		}
   169  		srv, err := p.SRVResource()
   170  		if err != nil {
   171  			return "", nil, &DNSError{
   172  				Err:    "cannot unmarshal DNS message",
   173  				Name:   name,
   174  				Server: server,
   175  			}
   176  		}
   177  		srvs = append(srvs, &SRV{Target: srv.Target.String(), Port: srv.Port, Priority: srv.Priority, Weight: srv.Weight})
   178  	}
   179  	byPriorityWeight(srvs).sort()
   180  	return cname.String(), srvs, nil
   181  }
   182  
   183  func (r *Resolver) lookupMX(ctx context.Context, name string) ([]*MX, error) {
   184  	p, server, err := r.lookup(ctx, name, dnsmessage.TypeMX)
   185  	if err != nil {
   186  		return nil, err
   187  	}
   188  	var mxs []*MX
   189  	for {
   190  		h, err := p.AnswerHeader()
   191  		if err == dnsmessage.ErrSectionDone {
   192  			break
   193  		}
   194  		if err != nil {
   195  			return nil, &DNSError{
   196  				Err:    "cannot unmarshal DNS message",
   197  				Name:   name,
   198  				Server: server,
   199  			}
   200  		}
   201  		if h.Type != dnsmessage.TypeMX {
   202  			if err := p.SkipAnswer(); err != nil {
   203  				return nil, &DNSError{
   204  					Err:    "cannot unmarshal DNS message",
   205  					Name:   name,
   206  					Server: server,
   207  				}
   208  			}
   209  			continue
   210  		}
   211  		mx, err := p.MXResource()
   212  		if err != nil {
   213  			return nil, &DNSError{
   214  				Err:    "cannot unmarshal DNS message",
   215  				Name:   name,
   216  				Server: server,
   217  			}
   218  		}
   219  		mxs = append(mxs, &MX{Host: mx.MX.String(), Pref: mx.Pref})
   220  
   221  	}
   222  	byPref(mxs).sort()
   223  	return mxs, nil
   224  }
   225  
   226  func (r *Resolver) lookupNS(ctx context.Context, name string) ([]*NS, error) {
   227  	p, server, err := r.lookup(ctx, name, dnsmessage.TypeNS)
   228  	if err != nil {
   229  		return nil, err
   230  	}
   231  	var nss []*NS
   232  	for {
   233  		h, err := p.AnswerHeader()
   234  		if err == dnsmessage.ErrSectionDone {
   235  			break
   236  		}
   237  		if err != nil {
   238  			return nil, &DNSError{
   239  				Err:    "cannot unmarshal DNS message",
   240  				Name:   name,
   241  				Server: server,
   242  			}
   243  		}
   244  		if h.Type != dnsmessage.TypeNS {
   245  			if err := p.SkipAnswer(); err != nil {
   246  				return nil, &DNSError{
   247  					Err:    "cannot unmarshal DNS message",
   248  					Name:   name,
   249  					Server: server,
   250  				}
   251  			}
   252  			continue
   253  		}
   254  		ns, err := p.NSResource()
   255  		if err != nil {
   256  			return nil, &DNSError{
   257  				Err:    "cannot unmarshal DNS message",
   258  				Name:   name,
   259  				Server: server,
   260  			}
   261  		}
   262  		nss = append(nss, &NS{Host: ns.NS.String()})
   263  	}
   264  	return nss, nil
   265  }
   266  
   267  func (r *Resolver) lookupTXT(ctx context.Context, name string) ([]string, error) {
   268  	p, server, err := r.lookup(ctx, name, dnsmessage.TypeTXT)
   269  	if err != nil {
   270  		return nil, err
   271  	}
   272  	var txts []string
   273  	for {
   274  		h, err := p.AnswerHeader()
   275  		if err == dnsmessage.ErrSectionDone {
   276  			break
   277  		}
   278  		if err != nil {
   279  			return nil, &DNSError{
   280  				Err:    "cannot unmarshal DNS message",
   281  				Name:   name,
   282  				Server: server,
   283  			}
   284  		}
   285  		if h.Type != dnsmessage.TypeTXT {
   286  			if err := p.SkipAnswer(); err != nil {
   287  				return nil, &DNSError{
   288  					Err:    "cannot unmarshal DNS message",
   289  					Name:   name,
   290  					Server: server,
   291  				}
   292  			}
   293  			continue
   294  		}
   295  		txt, err := p.TXTResource()
   296  		if err != nil {
   297  			return nil, &DNSError{
   298  				Err:    "cannot unmarshal DNS message",
   299  				Name:   name,
   300  				Server: server,
   301  			}
   302  		}
   303  		// Multiple strings in one TXT record need to be
   304  		// concatenated without separator to be consistent
   305  		// with previous Go resolver.
   306  		n := 0
   307  		for _, s := range txt.TXT {
   308  			n += len(s)
   309  		}
   310  		txtJoin := make([]byte, 0, n)
   311  		for _, s := range txt.TXT {
   312  			txtJoin = append(txtJoin, s...)
   313  		}
   314  		if len(txts) == 0 {
   315  			txts = make([]string, 0, 1)
   316  		}
   317  		txts = append(txts, string(txtJoin))
   318  	}
   319  	return txts, nil
   320  }
   321  
   322  func (r *Resolver) lookupAddr(ctx context.Context, addr string) ([]string, error) {
   323  	if !r.preferGo() && systemConf().canUseCgo() {
   324  		if ptrs, err, ok := cgoLookupPTR(ctx, addr); ok {
   325  			return ptrs, err
   326  		}
   327  	}
   328  	return r.goLookupPTR(ctx, addr)
   329  }
   330  
   331  // concurrentThreadsLimit returns the number of threads we permit to
   332  // run concurrently doing DNS lookups via cgo. A DNS lookup may use a
   333  // file descriptor so we limit this to less than the number of
   334  // permitted open files. On some systems, notably Darwin, if
   335  // getaddrinfo is unable to open a file descriptor it simply returns
   336  // EAI_NONAME rather than a useful error. Limiting the number of
   337  // concurrent getaddrinfo calls to less than the permitted number of
   338  // file descriptors makes that error less likely. We don't bother to
   339  // apply the same limit to DNS lookups run directly from Go, because
   340  // there we will return a meaningful "too many open files" error.
   341  func concurrentThreadsLimit() int {
   342  	var rlim syscall.Rlimit
   343  	if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rlim); err != nil {
   344  		return 500
   345  	}
   346  	r := int(rlim.Cur)
   347  	if r > 500 {
   348  		r = 500
   349  	} else if r > 30 {
   350  		r -= 30
   351  	}
   352  	return r
   353  }
   354  

View as plain text