badguardhome/internal/dnsforward/dnsrewrite.go

package dnsforward

import (
	"fmt"
	"net"

	"github.com/AdguardTeam/AdGuardHome/internal/filtering"
	"github.com/AdguardTeam/dnsproxy/proxy"
	"github.com/AdguardTeam/golibs/errors"
	"github.com/AdguardTeam/golibs/log"
	"github.com/AdguardTeam/urlfilter/rules"
	"github.com/miekg/dns"
)

// filterDNSRewriteResponse handles a single DNS rewrite response entry.
// It returns the properly constructed answer resource record.
func (s *Server) filterDNSRewriteResponse(req *dns.Msg, rr rules.RRType, v rules.RRValue) (ans dns.RR, err error) {
	// TODO(a.garipov): As more types are added, we will probably want to
	// use a handler-oriented approach here.  So, think of a way to decouple
	// the answer generation logic from the Server.

	switch rr {
	case dns.TypeA,
		dns.TypeAAAA:
		ip, ok := v.(net.IP)
		if !ok {
			return nil, fmt.Errorf("value for rr type %d has type %T, not net.IP", rr, v)
		}

		if rr == dns.TypeA {
			return s.genAnswerA(req, ip.To4()), nil
		}

		return s.genAnswerAAAA(req, ip), nil
	case dns.TypePTR,
		dns.TypeTXT:
		str, ok := v.(string)
		if !ok {
			return nil, fmt.Errorf("value for rr type %d has type %T, not string", rr, v)
		}

		if rr == dns.TypeTXT {
			return s.genAnswerTXT(req, []string{str}), nil
		}

		return s.genAnswerPTR(req, str), nil
	case dns.TypeMX:
		mx, ok := v.(*rules.DNSMX)
		if !ok {
			return nil, fmt.Errorf("value for rr type %d has type %T, not *rules.DNSMX", rr, v)
		}

		return s.genAnswerMX(req, mx), nil
	case dns.TypeHTTPS,
		dns.TypeSVCB:
		svcb, ok := v.(*rules.DNSSVCB)
		if !ok {
			return nil, fmt.Errorf("value for rr type %d has type %T, not *rules.DNSSVCB", rr, v)
		}

		if rr == dns.TypeHTTPS {
			return s.genAnswerHTTPS(req, svcb), nil
		}

		return s.genAnswerSVCB(req, svcb), nil
	case dns.TypeSRV:
		srv, ok := v.(*rules.DNSSRV)
		if !ok {
			return nil, fmt.Errorf("value for rr type %d has type %T, not *rules.DNSSRV", rr, v)
		}

		return s.genAnswerSRV(req, srv), nil
	default:
		log.Debug("don't know how to handle dns rr type %d, skipping", rr)

		return nil, nil
	}
}

// filterDNSRewrite handles dnsrewrite filters.  It constructs a DNS
// response and sets it into d.Res.
func (s *Server) filterDNSRewrite(req *dns.Msg, res filtering.Result, d *proxy.DNSContext) (err error) {
	resp := s.makeResponse(req)
	dnsrr := res.DNSRewriteResult
	if dnsrr == nil {
		return errors.Error("no dns rewrite rule content")
	}

	resp.Rcode = dnsrr.RCode
	if resp.Rcode != dns.RcodeSuccess {
		d.Res = resp

		return nil
	}

	if dnsrr.Response == nil {
		return errors.Error("no dns rewrite rule responses")
	}

	rr := req.Question[0].Qtype
	values := dnsrr.Response[rr]
	for i, v := range values {
		var ans dns.RR
		ans, err = s.filterDNSRewriteResponse(req, rr, v)
		if err != nil {
			return fmt.Errorf("dns rewrite response for %d[%d]: %w", rr, i, err)
		}

		resp.Answer = append(resp.Answer, ans)
	}

	d.Res = resp

	return nil
}