Method ServeDNS

plugin/cache/handler.go:17–89

ServeDNS implements the plugin.Handler interface.

(ctx context.Context, w dns.ResponseWriter, r *dns.Msg)

// ServeDNS implements the plugin.Handler interface.
func (c *Cache) ServeDNS(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) (int, error) {
	rc := r.Copy() // We potentially modify r, to prevent other plugins from seeing this (r is a pointer), copy r into rc.
	state := request.Request{W: w, Req: rc}
	do := state.Do()
	cd := r.CheckingDisabled
	ad := r.AuthenticatedData

	zone := plugin.Zones(c.Zones).Matches(state.Name())
	if zone == "" {
		return plugin.NextOrFailure(c.Name(), c.Next, ctx, w, rc)
	}

	now := c.now().UTC()
	server := metrics.WithServer(ctx)

	// On cache refresh, we will just use the DO bit from the incoming query for the refresh since we key our cache
	// with the query DO bit. That means two separate cache items for the query DO bit true or false. In the situation
	// in which upstream doesn't support DNSSEC, the two cache items will effectively be the same. Regardless, any
	// DNSSEC RRs in the response are written to cache with the response.

	i := c.getIfNotStale(now, state, server)
	if i == nil {
		crr := &ResponseWriter{ResponseWriter: w, Cache: c, state: state, server: server, do: do, ad: ad, cd: cd,
			nexcept: c.nexcept, pexcept: c.pexcept, wildcardFunc: wildcardFunc(ctx)}
		return c.doRefresh(ctx, state, crr)
	}
	ttl := i.ttl(now)
	if ttl < 0 {
		// serve stale behavior
		if c.verifyStale {
			crr := &ResponseWriter{ResponseWriter: w, Cache: c, state: state, server: server, do: do, cd: cd}
			if c.verifyStaleTimeout > 0 {
				// Background verify: cache the response but do not write to the wire.
				// On timeout, we serve the stale entry below and let the goroutine continue.
				crr.prefetch = true
			}
			cw := newVerifyStaleResponseWriter(crr)
			if c.verifyStaleTimeout == 0 {
				ret, err := c.doRefresh(ctx, state, cw)
				if cw.refreshed {
					return ret, err
				}
			} else if served, ret, err := c.verifyWithTimeout(ctx, state, w, cw, r, do, ad); served {
				return ret, err
			}
		}

		// Adjust the time to get a 0 TTL in the reply built from a stale item.
		now = now.Add(time.Duration(ttl) * time.Second)
		if !c.verifyStale {
			c.tryPrefetch(ctx, i, server, rc, do, cd, now)
		}
		servedStale.WithLabelValues(server, c.zonesMetricLabel, c.viewMetricLabel).Inc()
	} else if c.shouldPrefetch(i, now) {
		c.tryPrefetch(ctx, i, server, rc, do, cd, now)
	}

	if i.wildcard != "" {