Пример #1
0
Файл: cache.go Проект: cznic/dns
func (c *Cache) add(name string, rrs rr.RRs) {
	newparts := rrs.Partition(true)
	if tidy(0, newparts) && len(newparts) == 0 { // nothing left to add
		return
	}

	now := time.Now().Unix()
	for _, part := range newparts {
		for _, rec := range part {
			rec.TTL = int32(now - secs0 + int64(rec.TTL))
		}
	}

	c.rwm.Lock()         // W++
	defer c.rwm.Unlock() // W--

	if oldparts, hit, _ := c.get0(name); hit {
		newparts.SetAdd(oldparts)
	}
	c.tree.Put(name, newparts.Join().Pack())
}
Пример #2
0
// Lookup is a general DNS lookup function (rfc1034/p.30). It attempts to
// retrieve arbitrary information from the DNS. The caller supplies a sname,
// stype and sclass, and wants all of the matching RRs. Lookup should normally
// report "DNS lookup error" results via the return result variable.  A non-nil
// Error is returned for any non-lookup error event. The rd parameter is the
// msg.Messsage.Header "Recursion Desired" flag. Lookup CNAMEs chain walked, if
// any, is returned in redirects.
func (r *Resolver) Lookup(sname string, stype msg.QType, sclass rr.Class, rd bool) (answer, redirects rr.RRs, result LookupResult, err error) {

	defer func() {
		if e := recover(); e != nil {
			if r.log.Level >= dns.LOG_ERRORS {
				r.log.Log("FAIL Lookup error: %s", e.(error))
			}
		}
	}()

	var slist *srvlist
	var reply *msg.Message
	var srv server // current server asked
	var ip net.IP  // current IP asked

	retry := 0   // number of requests sent for missing addresses of known nameservers
	iserver := 0 // index into slist servers
	sname = dns.RootedName(strings.ToLower(sname))
	aliases := map[string]bool{strings.ToLower(sname): true} // CNAME loop detection

	// rfc1034/5.3.3
	// The top level algorithm has four steps:

step1:
	//=================================================================
	//   1. See if the answer is in local information, and if so return
	//      it to the client.

	bestmatch := -2 // sbelt has -1
	nodata, nxdomain, sname0 := false, false, sname

	answer = r.cached(sname,

		func(rec *rr.RR) bool {
			switch {
			case sclass != rec.Class:
				return false
			case stype == msg.QTYPE_STAR:
				return true
			case rec.Type == rr.TYPE_NXDOMAIN:
				nxdomain = true
				return false
			case rec.Type == rr.TYPE_NODATA && rr.Type(stype) == rec.RData.(*rr.NODATA).Type:
				nodata = true
				return false
			case rec.Type == rr.TYPE_CNAME && stype != msg.QTYPE_CNAME:
				cname := strings.ToLower(rec.RData.(*rr.CNAME).Name)
				if aliases[cname] {
					result = LookupAliasLoop
					return false
				}

				redirects = append(redirects, rec)
				sname = cname
				aliases[sname] = true
				result = LookupAliased
				return false
			default:
				return rr.Type(stype) == rec.Type
			}
			panic("unreachable")
		})

	switch {
	case result == LookupAliasLoop:
		return
	case len(answer) != 0:
		return
	case sname != sname0:
		goto step1
	case nxdomain: // NXDOMAIN resolved from cache
		switch result {
		case LookupAliased:
			result = LookupAliasError
		default:
			result = LookupNameError
		}
		return
	case nodata: // NODATA resolved from cache
		result = LookupDataNotFound
		return
	}

step2:
	//=================================================================
	//   2. Find the best servers to ask.
	// Step 2 looks for a name server to ask for the required data.  The
	// general strategy is to look for locally-available name server RRs,
	// starting at SNAME, then the parent domain name of SNAME, the
	// grandparent, and so on toward the root.  Thus if SNAME were
	// Mockapetris.ISI.EDU, this step would look for NS RRs for
	// Mockapetris.ISI.EDU, then ISI.EDU, then EDU, and then . (the root).
	// These NS RRs list the names of hosts for a zone at or above SNAME.
	// Copy the names into SLIST.  Set up their addresses using local data.
	// It may be the case that the addresses are not available.  The
	// resolver has many choices here; the best is to start parallel
	// resolver processes looking for the addresses while continuing onward
	// with the addresses which are available.

	var slabels []string
	if slabels, err = dns.Labels(sname); err != nil {
		return
	}

	slist = &srvlist{conf: r.getQueryConf()}
	srvmap := map[string]bool{}

	for len(slabels) != 0 {
		q := strings.Join(slabels, ".")

		if nss := r.cached(q,

			func(rec *rr.RR) bool {
				if rec.Class == sclass && rec.Type == rr.TYPE_NS {
					nm := strings.ToLower(rec.RData.(*rr.NS).NSDName)
					// Name servers for a domain are
					// themselves generally anywhere in the
					// DNS tree and the same NS may serve
					// otherwise unrelated parts of the DNS
					// tree (i.e. separated zones). Thus we
					// can see the same one(s) again while
					// walking the slabels towards root.
					// Avoid adding a same NS more than
					// once to the SLIST.
					if !srvmap[nm] {
						srvmap[nm] = true
						return true
					} // else rejecting duplicate nameserver nm
				}
				return false

			}); nss != nil {

			for _, ns := range nss {
				// check ns NS
				var matchcount int
				if matchcount, err = dns.MatchCount(sname, ns.Name); err != nil {
					if r.log.Level >= dns.LOG_ERRORS {
						r.log.Log("Matchcount: %s", err)
					}
					err = nil // not fatal, but ignore the NS RR
					continue
				}

				if matchcount <= bestmatch { // ignore
					continue
				}

				// matchcount > bestmatch => chance
				nsdname := ns.RData.(*rr.NS).NSDName

				if as := r.cached(nsdname,

					func(r *rr.RR) bool {
						return r.Class == sclass && (r.Type == rr.TYPE_A || r.Type == rr.TYPE_AAAA)

					}); as != nil {

					// got len(as) addresses for ns
					srv := server{name: nsdname, zone: ns.Name, matchcount: matchcount, attempts: int(slist.conf.Conf.Opt.Attempts)}
					for _, a := range as {
						var ip net.IP
						switch x := a.RData.(type) {
						default:
							log.Fatalf("FAIL internal error %T", x)
						case *rr.A:
							ip = x.Address
						case *rr.AAAA:
							ip = x.Address
						}
						srv.ips = append(srv.ips, ip)
					}
					slist.servers = append(slist.servers, srv)
					continue
				}

				// We have a nice candidate NS but have no A
				// nor AAAA RRs for it.  Could be due to
				// missing glue record(s) or their expired
				// TTLs.  Enter emergency panic mode for the
				// missing address(es).
				r.needNSAdr(nsdname)
				retry++

			}
		}
		slabels = slabels[1:] // level up
	}

	if len(slist.servers) == 0 {
		slist = r.sbelt()
		if r.log.Level >= dns.LOG_DEBUG {
			r.log.Log("%q: using sbelt", sname)
		}
	}
	sort.Sort(slist)
	iserver = 0

step3:
	//=================================================================
	//   3. Send them queries until one returns a response.

	if r.log.Level >= dns.LOG_DEBUG {
		r.log.Log("slist servers %d", len(slist.servers))
	}
	rxbuf := make([]byte, 4500)

asking:
	for {
		if len(slist.servers) == 0 {
			if r.log.Level >= dns.LOG_DEBUG {
				r.log.Log("Lookup %q fail, no servers to ask", sname)
			}
			result = LookupFail
			return
		}

		if iserver >= len(slist.servers) {
			if r.log.Level >= dns.LOG_DEBUG {
				r.log.Log("Lookup %q giving up without getting a valid response", sname)
			}
			result = LookupFail
			return
		}

		srv = slist.servers[iserver]
		if srv.matchcount <= bestmatch {
			if retry == 0 {
				if r.log.Level >= dns.LOG_DEBUG {
					r.log.Log("Lookup %q giving up due to no progress in matching", sname)
				}
				result = LookupFail
				return
			}

			// retry due to pending NS addresses requests
			<-time.After(1e9 / 2)
			retry >>= 1
			goto step2

		}

		const qmark = "------------------------------------------------------------------------------"
		const rmark = "=============================================================================="

		const (
			attemptUDP = iota
			attemptENDS
		)

		// try server srv
		for attempts := 0; attempts < srv.attempts; attempts++ {
			for _, ip = range srv.ips {

				attempting := attemptUDP

			reAttempt:
				m := msg.New()
				m.Question.Append(sname, stype, sclass)
				if attempting == attemptENDS {
					m.Additional = rr.RRs{optRR}
				}
				m.Header.RD = rd // Recursion Desired
				if r.log.Level >= dns.LOG_TRACE {
					if r.log.Level >= dns.LOG_DEBUG {
						r.log.Log("\n%s(QUERY MSG for %q @ %s)\n%s\n%s\n", qmark, srv.name, ip, m, qmark)
					} else {
						r.log.Log("asking %q @ %s, Q: %s", srv.name, ip, m.Question)
					}
				}
				adr, err := net.ResolveUDPAddr("udp", ip.String()+":53")
				if err != nil {
					if r.log.Level >= dns.LOG_ERRORS {
						r.log.Log("FAIL net.ResolveUDPAddr: %s", err)
					}
					continue
				}
				c, err := net.DialUDP("udp", nil, adr)
				if err != nil {
					if r.log.Level >= dns.LOG_ERRORS {
						r.log.Log("FAIL net.DialUDP: %s", err)
					}
					continue
				}

				defer c.Close()

				c.SetDeadline(time.Now().Add(time.Duration(slist.conf.Conf.Opt.TimeoutSecs) * time.Second))
				var rxbytes int
				if rxbytes, reply, err = m.ExchangeBuf(c, rxbuf); err != nil {
					if r.log.Level >= dns.LOG_ERRORS {
						r.log.Log("FAIL ExchangeBuf: %s", err)
					}
					continue
				}

				// got a response
				if r.log.Level >= dns.LOG_TRACE {
					if r.log.Level >= dns.LOG_DEBUG {
						r.log.Log("\n%s(REPLY MSG from %q @ %s)\n%s\nWire:\n%s\n%s\n", rmark, srv.name, ip, reply, hex.Dump(rxbuf[:rxbytes]), rmark)
					} else {
						r.log.Log("got a response for %q from %q @ %s", sname, srv.name, ip)
					}
				}
				h := &reply.Header

				if h.TC {
					switch attempting {
					case attemptUDP:
						attempting = attemptENDS
						goto reAttempt
					}
				}

				reject := h.ID != m.Header.ID ||
					!h.QR ||
					h.Opcode != m.Header.Opcode ||
					h.TC ||
					h.Z ||
					h.QDCOUNT != m.Header.QDCOUNT

				if reject {
					continue

				}

				break asking // response accepted

			}
		}

		iserver++
	}

	if srv.matchcount <= bestmatch {
		log.Fatalf("FAIL internal error %d <= %d", srv.matchcount, bestmatch)
	}

	if r.log.Level > dns.LOG_DEBUG {
		r.log.Log("%q bestmatch %d -> %d", sname, bestmatch, srv.matchcount)
	}
	bestmatch = srv.matchcount

	//step4:

	other := rr.RRs{}
	cnames := rr.RRs{} // only those matching sname
	soa := (*rr.RR)(nil)
	soadata := (*rr.SOA)(nil)

	answer, other = reply.Answer.Filter(func(r *rr.RR) bool {
		return sclass == r.Class && (stype == msg.QTYPE_STAR || r.Type == rr.Type(stype)) && strings.ToLower(r.Name) == sname
	})
	cnames, other = other.Filter(func(r *rr.RR) bool {
		return sclass == r.Class && r.Type == rr.TYPE_CNAME && strings.ToLower(r.Name) == sname
	})
	soas, ns := reply.Authority.Filter(func(r *rr.RR) bool {
		return sclass == r.Class && r.Type == rr.TYPE_SOA
	})
	// Authority NSs sanity check
	ns, _ = ns.Filter(func(rec *rr.RR) (y bool) {
		mc, _ := dns.MatchCount(sname, rec.Name)
		return mc > bestmatch
	})
	if len(soas) == 1 {
		soa = soas[0]
		soadata = soa.RData.(*rr.SOA)
	}

	//=================================================================
	//   4. Analyze the response, either:

	switch {

	//-----------------------------------------------------------------
	//       4.a. if the response answers the question or contains a name
	//            error, cache the data as well as returning it back to
	//            the client.
	case reply.RCODE == msg.RC_NO_ERROR && len(answer) != 0:
		r.cache.Add(reply.Answer, soas, ns, reply.Additional)
		answer.Unique() // improve some bad configured server responses
		return

	case reply.RCODE == msg.RC_NAME_ERROR:
		r.cache.Add(reply.Answer, soas, ns, reply.Additional)

		//   rfc2038/5 cache NXDOMAIN
		if reply.AA && len(soas) == 1 {
			ttl := soa.TTL
			if ttl2 := int32(soadata.Minimum); ttl2 < ttl {
				ttl = ttl2
			}
			r.cache.Add(rr.RRs{&rr.RR{sname, rr.TYPE_NXDOMAIN, sclass, ttl, &rr.NXDOMAIN{}}})
		}

		switch result {
		case LookupAliased:
			result = LookupAliasError
		default:
			result = LookupNameError
		}

		return

	//-----------------------------------------------------------------
	//   rfc2038/2.2 - No Data
	//
	//   NODATA is indicated by an answer with the RCODE set to NOERROR and
	//   no relevant answers in the answer section.  The authority section
	//   will contain an SOA record, or there will be no NS records there.
	case reply.RCODE == msg.RC_NO_ERROR && reply.ANCOUNT == 0 && (len(soas) == 1 || len(ns) == 0):
		r.cache.Add(reply.Answer, soas, ns, reply.Additional)

		//   rfc2038/5 cache NODATA
		if reply.AA {
			ttl := soa.TTL
			if ttl2 := int32(soadata.Minimum); ttl2 < ttl {
				ttl = ttl2
			}
			r.cache.Add(rr.RRs{&rr.RR{sname, rr.TYPE_NODATA, sclass, ttl, &rr.NODATA{rr.Type(stype)}}})
		}
		result = LookupDataNotFound
		return

	//-----------------------------------------------------------------
	//       4.c. if the response shows a CNAME and that is not the
	//            answer itself, cache the CNAME, change the SNAME to the
	//            canonical name in the CNAME RR and go to step 1.
	case reply.RCODE == msg.RC_NO_ERROR && len(cnames) == 1:
		r.cache.Add(reply.Answer, soas, ns, reply.Additional)

		cn := cnames[0]
		cname := cn.RData.(*rr.CNAME)
		for chain := true; chain; {

			sname = strings.ToLower(cname.Name) // next name in chain

			if aliases[sname] {
				result = LookupAliasLoop
				return
			}

			aliases[sname] = true
			redirects = append(redirects, cn)
			chain = false
			for _, cn = range other {
				if cn.Type == rr.TYPE_CNAME && strings.ToLower(cn.Name) == sname {
					cname, chain = cn.RData.(*rr.CNAME), true
					break
				}
			}
		}
		result = LookupAliased
		goto step1

	//-----------------------------------------------------------------
	//       4.b. if the response contains a better delegation to other
	//            servers, cache the delegation information, and go to
	//            step 2.
	case reply.RCODE == msg.RC_NO_ERROR && len(ns) != 0:
		r.cache.Add(soas, ns, reply.Additional)
		goto step2

	//-----------------------------------------------------------------
	//       4.d. if the response shows a servers failure or other
	//            bizarre contents, delete the server from the SLIST and
	//            go back to step 3.
	default:
		goto step3 // "delete from the SLIST" is performed by iserver incrementing in step 3
	}

	panic("unreachable")
}