community
/
dns
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cleanups; rm unused stuff

This commit is contained in:
Miek Gieben 2010-12-23 14:31:36 +01:00
parent 6be0c49d98
commit 94de3401fe
3 changed files with 0 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Makefile
View File

@ -6,7 +6,6 @@ include $(GOROOT)/src/Make.inc
TARG=dns
GOFILES=\
parse.go\
msg.go\
resolver.go \
types.go\

179
deadcode.go
View File

@ -1,179 +0,0 @@
// Find answer for name in dns message.
// On return, if err == nil, addrs != nil.
func answer(name, server string, dns *Msg, qtype uint16) (addrs []RR, err os.Error) {
addrs = make([]RR, 0, len(dns.Answer))
if dns.rcode == RcodeNameError && dns.recursion_available {
return nil, &DnsError{Error: noSuchHost, Name: name}
}
if dns.rcode != RcodeSuccess {
// 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.
return nil, &DnsError{Error: "server misbehaving", Name: name, Server: server}
}
// 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()
if h.Class == ClassINET && h.Name == name {
switch h.Rrtype {
case qtype:
n := len(addrs)
addrs = addrs[0 : n+1]
addrs[n] = rr
case TypeCNAME:
// redirect to cname
name = rr.(*RR_CNAME).Cname
continue Cname
}
}
}
if len(addrs) == 0 {
return nil, &DnsError{Error: noSuchHost, Name: name, Server: server}
}
return addrs, nil
}
return nil, &DnsError{Error: "too many redirects", Name: name, Server: server}
}
// Do a lookup for a single name, which must be rooted
// (otherwise answer will not find the answers).
func (res *Resolver) TryOneName(name string, qtype uint16) (addrs []RR, err os.Error) {
if len(res.Servers) == 0 {
return nil, &DnsError{Error: "no DNS servers", Name: name}
}
for i := 0; i < len(res.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 res.Servers[i] are IP addresses, which
// Dial will use without a DNS lookup.
server := res.Servers[i] + ":53"
c, cerr := net.Dial("udp", "", server)
if cerr != nil {
err = cerr
continue
}
msg, merr := Exchange(res, c, name, qtype, ClassINET)
c.Close()
if merr != nil {
err = merr
continue
}
addrs, err = answer(name, server, msg, qtype)
if err == nil || err.(*DnsError).Error == noSuchHost {
break
}
}
return
}
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
}
func lookup(name string, qtype uint16) (cname string, addrs []RR, err os.Error) {
if !isDomainName(name) {
return name, nil, &DnsError{Error: "invalid domain name", Name: name}
}
if dnserr != nil || res == nil {
err = dnserr
return
}
// If name is rooted (trailing dot) or has enough dots,
// try it by itself first.
rooted := len(name) > 0 && name[len(name)-1] == '.'
if rooted || count(name, '.') >= res.Ndots {
rname := name
if !rooted {
rname += "."
}
// Can try as ordinary name.
addrs, err = res.TryOneName(rname, qtype)
if err == nil {
cname = rname
return
}
}
if rooted {
return
}
// Otherwise, try suffixes.
for i := 0; i < len(res.Search); i++ {
rname := name + "." + res.Search[i]
if rname[len(rname)-1] != '.' {
rname += "."
}
addrs, err = res.TryOneName(rname, qtype)
if err == nil {
cname = rname
return
}
}
// Last ditch effort: try unsuffixed.
rname := name
if !rooted {
rname += "."
}
addrs, err = res.TryOneName(rname, qtype)
if err == nil {
cname = rname
return
}
return
}

26
msg.go
View File

@ -438,32 +438,6 @@ func unpackStruct(any interface{}, msg []byte, off int) (off1 int, ok bool) {
return off, ok
}
// THIS can GO TODO
// Generic struct printer.
// Doesn't care about the string tag "domain-name",
func printStructValue(val *reflect.StructValue) string {
s := "{"
for i := 0; i < val.NumField(); i++ {
if i > 0 {
s += ", "
}
f := val.Type().(*reflect.StructType).Field(i)
if !f.Anonymous {
s += f.Name + "="
}
fval := val.Field(i)
if fv, ok := fval.(*reflect.StructValue); ok {
s += printStructValue(fv)
} else {
s += fmt.Sprint(fval.Interface())
}
}
s += "}"
return s
}
func PrintStruct(any interface{}) string { return printStructValue(structValue(any)) }
// Resource record packer.
func packRR(rr RR, msg []byte, off int) (off2 int, ok bool) {
var off1 int