typify.go at 9e73ec1 ⋅ semihalev/sdns

// Copyright 2016-2020 The CoreDNS authors and contributors
// Adapted for SDNS usage by Semih Alev.

package response

import (
	"fmt"
	"time"

	"github.com/miekg/dns"
)

// Type is the type of the message.
type Type int

const (
	// NoError indicates a positive reply
	NoError Type = iota
	// NameError is a NXDOMAIN in header, SOA in auth.
	NameError
	// NoData indicates name found, but not the type: NOERROR in header, SOA in auth.
	NoData
	// Delegation is a msg with a pointer to another nameserver: NOERROR in header, NS in auth, optionally fluff in additional (not checked).
	Delegation
	// Meta indicates a meta message, NOTIFY, or a transfer:  qType is IXFR or AXFR.
	Meta
	// Update is an dynamic update message.
	Update
	// OtherError indicates any other error.
	OtherError
	// Expired if sigs expired: don't cache these
	Expired
	// NoCache indicates a no cache reply
	NoCache
)

var toString = map[Type]string{
	NoError:    "NOERROR",
	NameError:  "NXDOMAIN",
	NoData:     "NODATA",
	Delegation: "DELEGATION",
	Meta:       "META",
	Update:     "UPDATE",
	OtherError: "OTHERERROR",
	Expired:    "EXPIRED",
	NoCache:    "NOCACHE",
}

func (t Type) String() string { return toString[t] }

// TypeFromString returns the type from the string s. If not type matches
// the OtherError type and an error are returned.
func TypeFromString(s string) (Type, error) {
	for t, str := range toString {
		if s == str {
			return t, nil
		}
	}
	return NoError, fmt.Errorf("invalid Type: %s", s)
}

// Typify classifies a message, it returns the Type.
func Typify(m *dns.Msg, t time.Time) (Type, *dns.OPT) {
	if m == nil {
		return OtherError, nil
	}
	opt := m.IsEdns0()
	do := false
	if opt != nil {
		do = opt.Do()
	}

	if m.Opcode == dns.OpcodeUpdate {
		return Update, opt
	}

	// Check transfer and update first
	if m.Opcode == dns.OpcodeNotify {
		return Meta, opt
	}

	if len(m.Question) > 0 {
		if m.Question[0].Qtype == dns.TypeAXFR || m.Question[0].Qtype == dns.TypeIXFR {
			return Meta, opt
		}
	}

	// If our message contains any expired sigs and we care about that, we should return expired
	if do {
		if expired := typifyExpired(m, t); expired {
			return Expired, opt
		}
	}

	if len(m.Answer) > 0 && m.Rcode == dns.RcodeSuccess {
		return NoError, opt
	}

	soa := false
	ns := 0
	for _, r := range m.Ns {
		if r.Header().Rrtype == dns.TypeSOA {
			soa = true
			continue
		}
		if r.Header().Rrtype == dns.TypeNS {
			ns++
		}
	}

	if !soa && len(m.Question) > 0 {
		if len(m.Answer) == 0 && m.Question[0].Qtype == dns.TypeDNSKEY {
			return NoCache, opt
		}
	}

	if soa && m.Rcode == dns.RcodeSuccess {
		return NoData, opt
	}
	if soa && m.Rcode == dns.RcodeNameError {
		return NameError, opt
	}

	if ns > 0 && m.Rcode == dns.RcodeSuccess {
		return Delegation, opt
	}

	if m.Rcode == dns.RcodeSuccess {
		return NoError, opt
	}

	return OtherError, opt
}

func typifyExpired(m *dns.Msg, t time.Time) bool {
	if expired := typifyExpiredRRSIG(m.Answer, t); expired {
		return true
	}
	if expired := typifyExpiredRRSIG(m.Ns, t); expired {
		return true
	}
	if expired := typifyExpiredRRSIG(m.Extra, t); expired {
		return true
	}
	return false
}

func typifyExpiredRRSIG(rrs []dns.RR, t time.Time) bool {
	for _, r := range rrs {
		if r.Header().Rrtype != dns.TypeRRSIG {
			continue
		}
		ok := r.(*dns.RRSIG).ValidityPeriod(t)
		if !ok {
			return true
		}
	}
	return false
}

Read our documentation on viewing source code .

1		// Copyright 2016-2020 The CoreDNS authors and contributors
2		// Adapted for SDNS usage by Semih Alev.
3
4		package response
5
6		import (
7		"fmt"
8		"time"
9
10		"github.com/miekg/dns"
11		)
12
13		// Type is the type of the message.
14		type Type int
15
16		const (
17		// NoError indicates a positive reply
18		NoError Type = iota
19		// NameError is a NXDOMAIN in header, SOA in auth.
20		NameError
21		// NoData indicates name found, but not the type: NOERROR in header, SOA in auth.
22		NoData
23		// Delegation is a msg with a pointer to another nameserver: NOERROR in header, NS in auth, optionally fluff in additional (not checked).
24		Delegation
25		// Meta indicates a meta message, NOTIFY, or a transfer: qType is IXFR or AXFR.
26		Meta
27		// Update is an dynamic update message.
28		Update
29		// OtherError indicates any other error.
30		OtherError
31		// Expired if sigs expired: don't cache these
32		Expired
33		// NoCache indicates a no cache reply
34		NoCache
35		)
36
37		var toString = map[Type]string{
38		NoError: "NOERROR",
39		NameError: "NXDOMAIN",
40		NoData: "NODATA",
41		Delegation: "DELEGATION",
42		Meta: "META",
43		Update: "UPDATE",
44		OtherError: "OTHERERROR",
45		Expired: "EXPIRED",
46		NoCache: "NOCACHE",
47		}
48
49	1	func (t Type) String() string { return toString[t] }
50
51		// TypeFromString returns the type from the string s. If not type matches
52		// the OtherError type and an error are returned.
53		func TypeFromString(s string) (Type, error) {
54		for t, str := range toString {
55	1	if s == str {
56	1	return t, nil
57		}
58		}
59	1	return NoError, fmt.Errorf("invalid Type: %s", s)
60		}
61
62		// Typify classifies a message, it returns the Type.
63		func Typify(m dns.Msg, t time.Time) (Type, dns.OPT) {
64	1	if m == nil {
65	1	return OtherError, nil
66		}
67	1	opt := m.IsEdns0()
68	1	do := false
69	1	if opt != nil {
70	1	do = opt.Do()
71		}
72
73	1	if m.Opcode == dns.OpcodeUpdate {
74	1	return Update, opt
75		}
76
77		// Check transfer and update first
78	1	if m.Opcode == dns.OpcodeNotify {
79	1	return Meta, opt
80		}
81
82	1	if len(m.Question) > 0 {
83	1	if m.Question[0].Qtype == dns.TypeAXFR \|\| m.Question[0].Qtype == dns.TypeIXFR {
84	1	return Meta, opt
85		}
86		}
87
88		// If our message contains any expired sigs and we care about that, we should return expired
89	1	if do {
90	1	if expired := typifyExpired(m, t); expired {
91	1	return Expired, opt
92		}
93		}
94
95	1	if len(m.Answer) > 0 && m.Rcode == dns.RcodeSuccess {
96	1	return NoError, opt
97		}
98
99	1	soa := false
100	1	ns := 0
101		for _, r := range m.Ns {
102	1	if r.Header().Rrtype == dns.TypeSOA {
103	1	soa = true
104	1	continue
105		}
106	1	if r.Header().Rrtype == dns.TypeNS {
107	1	ns++
108		}
109		}
110
111	1	if !soa && len(m.Question) > 0 {
112	1	if len(m.Answer) == 0 && m.Question[0].Qtype == dns.TypeDNSKEY {
113	0	return NoCache, opt
114		}
115		}
116
117	1	if soa && m.Rcode == dns.RcodeSuccess {
118	1	return NoData, opt
119		}
120	1	if soa && m.Rcode == dns.RcodeNameError {
121	1	return NameError, opt
122		}
123
124	1	if ns > 0 && m.Rcode == dns.RcodeSuccess {
125	1	return Delegation, opt
126		}
127
128	1	if m.Rcode == dns.RcodeSuccess {
129	1	return NoError, opt
130		}
131
132	1	return OtherError, opt
133		}
134
135		func typifyExpired(m *dns.Msg, t time.Time) bool {
136	1	if expired := typifyExpiredRRSIG(m.Answer, t); expired {
137	1	return true
138		}
139	1	if expired := typifyExpiredRRSIG(m.Ns, t); expired {
140	1	return true
141		}
142	1	if expired := typifyExpiredRRSIG(m.Extra, t); expired {
143	1	return true
144		}
145	1	return false
146		}
147
148		func typifyExpiredRRSIG(rrs []dns.RR, t time.Time) bool {
149		for _, r := range rrs {
150	1	if r.Header().Rrtype != dns.TypeRRSIG {
151	1	continue
152		}
153	1	ok := r.(*dns.RRSIG).ValidityPeriod(t)
154	1	if !ok {
155	1	return true
156		}
157		}
158	1	return false
159		}

Navigation	Overlay
`t` Navigate files	`h` Toggle hits
`y` Change url to tip of branch	`m` Toggle misses
`b / v` Jump to prev/next hit line	`p` Toggle partial
`z / x` Jump to prev/next missed or partial line	`1..9` Toggle flags
`shift + o` Open current page in GitHub	`a` Toggle all on
`/ or ?` Show keyboard shortcuts dialog	`c` Toggle context lines or commits