2008-12-18 16:42:39 -07:00
|
|
|
// Copyright 2009 The Go Authors. All rights reserved.
|
|
|
|
// Use of this source code is governed by a BSD-style
|
|
|
|
// license that can be found in the LICENSE file.
|
|
|
|
|
2009-06-25 21:24:55 -06:00
|
|
|
// DNS client: see RFC 1035.
|
2008-12-18 16:42:39 -07:00
|
|
|
// Has to be linked into package net for Dial.
|
|
|
|
|
|
|
|
// TODO(rsc):
|
|
|
|
// Check periodically whether /etc/resolv.conf has changed.
|
|
|
|
// Could potentially handle many outstanding lookups faster.
|
|
|
|
// Could have a small cache.
|
|
|
|
// Random UDP source port (net.Dial should do that for us).
|
|
|
|
// Random request IDs.
|
|
|
|
|
|
|
|
package net
|
|
|
|
|
|
|
|
import (
|
|
|
|
"once";
|
|
|
|
"os";
|
|
|
|
)
|
|
|
|
|
2009-06-25 21:24:55 -06:00
|
|
|
// DNSError represents a DNS lookup error.
|
2009-05-08 15:40:20 -06:00
|
|
|
type DNSError struct {
|
2009-06-25 21:24:55 -06:00
|
|
|
Error string; // description of the error
|
|
|
|
Name string; // name looked for
|
|
|
|
Server string; // server used
|
2009-05-08 15:40:20 -06:00
|
|
|
}
|
2009-06-25 21:24:55 -06:00
|
|
|
|
|
|
|
func (e *DNSError) String() string {
|
|
|
|
s := "lookup " + e.Name;
|
|
|
|
if e.Server != "" {
|
|
|
|
s += " on " + e.Server;
|
|
|
|
}
|
|
|
|
s += ": " + e.Error;
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
const noSuchHost = "no such host"
|
2008-12-18 16:42:39 -07:00
|
|
|
|
|
|
|
// Send a request on the connection and hope for a reply.
|
|
|
|
// Up to cfg.attempts attempts.
|
2009-04-17 01:08:24 -06:00
|
|
|
func _Exchange(cfg *_DNS_Config, c Conn, name string) (m *_DNS_Msg, err os.Error) {
|
2008-12-18 16:42:39 -07:00
|
|
|
if len(name) >= 256 {
|
2009-06-25 21:24:55 -06:00
|
|
|
return nil, &DNSError{"name too long", name, ""}
|
2008-12-18 16:42:39 -07:00
|
|
|
}
|
2009-03-05 16:48:12 -07:00
|
|
|
out := new(_DNS_Msg);
|
2008-12-18 16:42:39 -07:00
|
|
|
out.id = 0x1234;
|
2009-03-05 16:48:12 -07:00
|
|
|
out.question = []_DNS_Question{
|
|
|
|
_DNS_Question{ name, _DNS_TypeA, _DNS_ClassINET }
|
2009-03-03 09:39:12 -07:00
|
|
|
};
|
2008-12-18 16:42:39 -07:00
|
|
|
out.recursion_desired = true;
|
|
|
|
msg, ok := out.Pack();
|
|
|
|
if !ok {
|
2009-06-25 21:24:55 -06:00
|
|
|
return nil, &DNSError{"internal error - cannot pack message", name, ""}
|
2008-12-18 16:42:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
for attempt := 0; attempt < cfg.attempts; attempt++ {
|
|
|
|
n, err := c.Write(msg);
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2009-03-06 18:51:31 -07:00
|
|
|
c.SetReadTimeout(1e9); // nanoseconds
|
2008-12-18 16:42:39 -07:00
|
|
|
|
2009-01-06 16:19:02 -07:00
|
|
|
buf := make([]byte, 2000); // More than enough.
|
2008-12-18 16:42:39 -07:00
|
|
|
n, err = c.Read(buf);
|
2009-06-25 21:24:55 -06:00
|
|
|
if isEAGAIN(err) {
|
|
|
|
err = nil;
|
2009-03-06 18:51:31 -07:00
|
|
|
continue;
|
|
|
|
}
|
2008-12-18 16:42:39 -07:00
|
|
|
if err != nil {
|
2009-03-06 18:51:31 -07:00
|
|
|
return nil, err;
|
2008-12-18 16:42:39 -07:00
|
|
|
}
|
|
|
|
buf = buf[0:n];
|
2009-03-05 16:48:12 -07:00
|
|
|
in := new(_DNS_Msg);
|
2008-12-18 16:42:39 -07:00
|
|
|
if !in.Unpack(buf) || in.id != out.id {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
return in, nil
|
|
|
|
}
|
2009-06-25 21:24:55 -06:00
|
|
|
return nil, &DNSError{"no answer from server", name, c.RemoteAddr()}
|
2008-12-18 16:42:39 -07:00
|
|
|
}
|
|
|
|
|
2008-12-18 23:37:22 -07:00
|
|
|
|
2008-12-18 16:42:39 -07:00
|
|
|
// Find answer for name in dns message.
|
|
|
|
// On return, if err == nil, addrs != nil.
|
2009-06-25 21:24:55 -06:00
|
|
|
func answer(name, server string, dns *_DNS_Msg) (addrs []string, err *DNSError) {
|
2009-01-06 16:19:02 -07:00
|
|
|
addrs = make([]string, 0, len(dns.answer));
|
2008-12-18 16:42:39 -07:00
|
|
|
|
2009-06-25 21:24:55 -06:00
|
|
|
if dns.rcode == _DNS_RcodeNameError && dns.recursion_available {
|
|
|
|
return nil, &DNSError{noSuchHost, name, ""}
|
2008-12-18 16:42:39 -07:00
|
|
|
}
|
2009-03-05 16:48:12 -07:00
|
|
|
if dns.rcode != _DNS_RcodeSuccess {
|
2008-12-18 16:42:39 -07:00
|
|
|
// None of the error codes make sense
|
|
|
|
// for the query we sent. If we didn't get
|
|
|
|
// a name error and we didn't get success,
|
|
|
|
// the server is behaving incorrectly.
|
2009-06-25 21:24:55 -06:00
|
|
|
return nil, &DNSError{"server misbehaving", name, server}
|
2008-12-18 16:42:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// Look for the name.
|
|
|
|
// Presotto says it's okay to assume that servers listed in
|
|
|
|
// /etc/resolv.conf are recursive resolvers.
|
|
|
|
// We asked for recursion, so it should have included
|
|
|
|
// all the answers we need in this one packet.
|
|
|
|
Cname:
|
|
|
|
for cnameloop := 0; cnameloop < 10; cnameloop++ {
|
|
|
|
addrs = addrs[0:0];
|
|
|
|
for i := 0; i < len(dns.answer); i++ {
|
|
|
|
rr := dns.answer[i];
|
|
|
|
h := rr.Header();
|
2009-07-07 12:04:26 -06:00
|
|
|
if h.Class == _DNS_ClassINET && h.Name == name {
|
|
|
|
switch h.Rrtype {
|
2009-03-05 16:48:12 -07:00
|
|
|
case _DNS_TypeA:
|
2008-12-18 16:42:39 -07:00
|
|
|
n := len(addrs);
|
2009-07-07 12:04:26 -06:00
|
|
|
a := rr.(*_DNS_RR_A).A;
|
2008-12-18 16:42:39 -07:00
|
|
|
addrs = addrs[0:n+1];
|
2009-06-25 21:24:55 -06:00
|
|
|
addrs[n] = IPv4(byte(a>>24), byte(a>>16), byte(a>>8), byte(a)).String();
|
2009-03-05 16:48:12 -07:00
|
|
|
case _DNS_TypeCNAME:
|
2008-12-18 16:42:39 -07:00
|
|
|
// redirect to cname
|
2009-07-07 12:04:26 -06:00
|
|
|
name = rr.(*_DNS_RR_CNAME).Cname;
|
2008-12-18 16:42:39 -07:00
|
|
|
continue Cname
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if len(addrs) == 0 {
|
2009-06-25 21:24:55 -06:00
|
|
|
return nil, &DNSError{noSuchHost, name, server}
|
2008-12-18 16:42:39 -07:00
|
|
|
}
|
|
|
|
return addrs, nil
|
|
|
|
}
|
|
|
|
|
2009-06-25 21:24:55 -06:00
|
|
|
return nil, &DNSError{"too many redirects", name, server}
|
2008-12-18 16:42:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// Do a lookup for a single name, which must be rooted
|
2009-02-15 15:18:39 -07:00
|
|
|
// (otherwise answer will not find the answers).
|
2009-04-17 01:08:24 -06:00
|
|
|
func tryOneName(cfg *_DNS_Config, name string) (addrs []string, err os.Error) {
|
2009-06-25 21:24:55 -06:00
|
|
|
if len(cfg.servers) == 0 {
|
|
|
|
return nil, &DNSError{"no DNS servers", name, ""}
|
|
|
|
}
|
2008-12-18 16:42:39 -07:00
|
|
|
for i := 0; i < len(cfg.servers); i++ {
|
|
|
|
// Calling Dial here is scary -- we have to be sure
|
|
|
|
// not to dial a name that will require a DNS lookup,
|
|
|
|
// or Dial will call back here to translate it.
|
|
|
|
// The DNS config parser has already checked that
|
|
|
|
// all the cfg.servers[i] are IP addresses, which
|
|
|
|
// Dial will use without a DNS lookup.
|
2009-06-25 21:24:55 -06:00
|
|
|
server := cfg.servers[i] + ":53";
|
|
|
|
c, cerr := Dial("udp", "", server);
|
2008-12-18 16:42:39 -07:00
|
|
|
if cerr != nil {
|
|
|
|
err = cerr;
|
|
|
|
continue;
|
|
|
|
}
|
2009-01-16 12:04:44 -07:00
|
|
|
msg, merr := _Exchange(cfg, c, name);
|
2008-12-18 16:42:39 -07:00
|
|
|
c.Close();
|
|
|
|
if merr != nil {
|
|
|
|
err = merr;
|
|
|
|
continue;
|
|
|
|
}
|
2009-06-25 21:24:55 -06:00
|
|
|
var dnserr *DNSError;
|
|
|
|
addrs, dnserr = answer(name, server, msg);
|
|
|
|
if dnserr != nil {
|
|
|
|
err = dnserr;
|
|
|
|
} else {
|
|
|
|
err = nil; // nil os.Error, not nil *DNSError
|
|
|
|
}
|
|
|
|
if dnserr == nil || dnserr.Error == noSuchHost {
|
|
|
|
break;
|
2008-12-18 16:42:39 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-03-05 16:48:12 -07:00
|
|
|
var cfg *_DNS_Config
|
2009-04-17 01:08:24 -06:00
|
|
|
var dnserr os.Error
|
2008-12-18 16:42:39 -07:00
|
|
|
|
2009-02-15 15:18:39 -07:00
|
|
|
func loadConfig() {
|
2009-03-05 16:48:12 -07:00
|
|
|
cfg, dnserr = _DNS_ReadConfig();
|
2008-12-18 16:42:39 -07:00
|
|
|
}
|
|
|
|
|
2009-06-25 21:24:55 -06:00
|
|
|
func isDomainName(s string) bool {
|
|
|
|
// Requirements on DNS name:
|
|
|
|
// * must not be empty.
|
|
|
|
// * must be alphanumeric plus - and .
|
|
|
|
// * each of the dot-separated elements must begin
|
|
|
|
// and end with a letter or digit.
|
|
|
|
// RFC 1035 required the element to begin with a letter,
|
|
|
|
// but RFC 3696 says this has been relaxed to allow digits too.
|
|
|
|
// still, there must be a letter somewhere in the entire name.
|
|
|
|
if len(s) == 0 {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if s[len(s)-1] != '.' { // simplify checking loop: make name end in dot
|
|
|
|
s += ".";
|
|
|
|
}
|
|
|
|
|
|
|
|
last := byte('.');
|
|
|
|
ok := false; // ok once we've seen a letter
|
|
|
|
for i := 0; i < len(s); i++ {
|
|
|
|
c := s[i];
|
|
|
|
switch {
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
case 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z':
|
|
|
|
ok = true;
|
|
|
|
case '0' <= c && c <= '9':
|
|
|
|
// fine
|
|
|
|
case c == '-':
|
|
|
|
// byte before dash cannot be dot
|
|
|
|
if last == '.' {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
case c == '.':
|
|
|
|
// byte before dot cannot be dot, dash
|
|
|
|
if last == '.' || last == '-' {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
last = c;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ok;
|
|
|
|
}
|
|
|
|
|
2009-03-05 16:48:12 -07:00
|
|
|
// LookupHost looks up the host name using the local DNS resolver.
|
|
|
|
// It returns the canonical name for the host and an array of that
|
|
|
|
// host's addresses.
|
2009-06-25 21:24:55 -06:00
|
|
|
func LookupHost(name string) (cname string, addrs []string, err os.Error) {
|
|
|
|
if !isDomainName(name) {
|
|
|
|
return name, nil, &DNSError{"invalid domain name", name, ""};
|
|
|
|
}
|
2009-02-15 15:18:39 -07:00
|
|
|
once.Do(loadConfig);
|
2009-03-05 16:48:12 -07:00
|
|
|
if dnserr != nil || cfg == nil {
|
2009-06-25 21:24:55 -06:00
|
|
|
err = dnserr;
|
2008-12-18 16:42:39 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If name is rooted (trailing dot) or has enough dots,
|
|
|
|
// try it by itself first.
|
|
|
|
rooted := len(name) > 0 && name[len(name)-1] == '.';
|
2009-11-01 12:15:34 -07:00
|
|
|
if rooted || count(name, '.') >= cfg.ndots {
|
2008-12-18 16:42:39 -07:00
|
|
|
rname := name;
|
|
|
|
if !rooted {
|
|
|
|
rname += ".";
|
|
|
|
}
|
|
|
|
// Can try as ordinary name.
|
2009-06-25 21:24:55 -06:00
|
|
|
addrs, err = tryOneName(cfg, rname);
|
|
|
|
if err == nil {
|
|
|
|
cname = rname;
|
|
|
|
return;
|
2008-12-18 16:42:39 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if rooted {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, try suffixes.
|
|
|
|
for i := 0; i < len(cfg.search); i++ {
|
2009-06-25 21:24:55 -06:00
|
|
|
rname := name+"."+cfg.search[i];
|
|
|
|
if rname[len(rname)-1] != '.' {
|
|
|
|
rname += "."
|
2008-12-18 16:42:39 -07:00
|
|
|
}
|
2009-06-25 21:24:55 -06:00
|
|
|
addrs, err = tryOneName(cfg, rname);
|
|
|
|
if err == nil {
|
|
|
|
cname = rname;
|
|
|
|
return;
|
2008-12-18 16:42:39 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|