2011-03-16 22:19:15 +11:00
|
|
|
package dns
|
|
|
|
|
2011-03-30 20:14:36 +11:00
|
|
|
// Everything is assumed in the ClassINET class. If
|
|
|
|
// you need other classes you are on your own.
|
2011-03-23 06:12:36 +11:00
|
|
|
|
2011-09-11 20:57:06 +10:00
|
|
|
// SetReply creates a reply packet from a request message.
|
2011-03-23 19:50:38 +11:00
|
|
|
func (dns *Msg) SetReply(request *Msg) {
|
2011-03-24 19:24:24 +11:00
|
|
|
dns.MsgHdr.Id = request.MsgHdr.Id
|
|
|
|
dns.MsgHdr.Authoritative = true
|
|
|
|
dns.MsgHdr.Response = true
|
|
|
|
dns.MsgHdr.Opcode = OpcodeQuery
|
|
|
|
dns.MsgHdr.Rcode = RcodeSuccess
|
|
|
|
dns.Question = make([]Question, 1)
|
|
|
|
dns.Question[0] = request.Question[0]
|
2011-03-22 08:53:15 +11:00
|
|
|
}
|
|
|
|
|
2011-09-11 21:01:18 +10:00
|
|
|
// SetQuestion creates a question packet.
|
2011-04-15 06:22:24 +10:00
|
|
|
func (dns *Msg) SetQuestion(z string, t uint16) {
|
2011-07-06 04:52:35 +10:00
|
|
|
dns.MsgHdr.Id = Id()
|
|
|
|
dns.MsgHdr.RecursionDesired = true
|
2011-04-15 06:22:24 +10:00
|
|
|
dns.Question = make([]Question, 1)
|
|
|
|
dns.Question[0] = Question{z, t, ClassINET}
|
|
|
|
}
|
|
|
|
|
2011-09-11 21:01:18 +10:00
|
|
|
// SetNotify creates a notify packet.
|
2011-03-31 02:50:07 +11:00
|
|
|
func (dns *Msg) SetNotify(z string) {
|
2011-03-16 22:19:15 +11:00
|
|
|
dns.MsgHdr.Opcode = OpcodeNotify
|
|
|
|
dns.MsgHdr.Authoritative = true
|
|
|
|
dns.MsgHdr.Id = Id()
|
|
|
|
dns.Question = make([]Question, 1)
|
2011-03-31 02:50:07 +11:00
|
|
|
dns.Question[0] = Question{z, TypeSOA, ClassINET}
|
2011-03-16 22:19:15 +11:00
|
|
|
}
|
|
|
|
|
2011-09-11 21:01:18 +10:00
|
|
|
// SetRcode creates an error packet.
|
2011-07-27 03:16:28 +10:00
|
|
|
func (dns *Msg) SetRcode(request *Msg, rcode int) {
|
2011-11-28 16:03:21 +11:00
|
|
|
dns.MsgHdr.Rcode = rcode
|
|
|
|
dns.MsgHdr.Opcode = OpcodeQuery
|
|
|
|
dns.MsgHdr.Response = true
|
|
|
|
dns.MsgHdr.Authoritative = false
|
|
|
|
dns.MsgHdr.Id = request.MsgHdr.Id
|
|
|
|
dns.Question = make([]Question, 1)
|
|
|
|
dns.Question[0] = request.Question[0]
|
2011-07-27 03:16:28 +10:00
|
|
|
}
|
|
|
|
|
2011-09-11 21:01:18 +10:00
|
|
|
// SetRcodeFormatError creates a packet with FormError set.
|
2011-07-27 03:16:28 +10:00
|
|
|
func (dns *Msg) SetRcodeFormatError(request *Msg) {
|
2011-11-28 16:03:21 +11:00
|
|
|
dns.MsgHdr.Rcode = RcodeFormatError
|
|
|
|
dns.MsgHdr.Opcode = OpcodeQuery
|
|
|
|
dns.MsgHdr.Response = true
|
|
|
|
dns.MsgHdr.Authoritative = false
|
|
|
|
dns.MsgHdr.Id = request.MsgHdr.Id
|
2011-07-27 03:16:28 +10:00
|
|
|
}
|
|
|
|
|
2011-09-02 22:28:40 +10:00
|
|
|
// SetUpdate makes the message a dynamic update packet. It
|
|
|
|
// sets the ZONE section to: z, TypeSOA, classINET.
|
|
|
|
func (dns *Msg) SetUpdate(z string) {
|
2012-01-20 22:24:20 +11:00
|
|
|
dns.MsgHdr.Id = Id()
|
|
|
|
dns.MsgHdr.Opcode = OpcodeUpdate
|
|
|
|
dns.Question = make([]Question, 1)
|
|
|
|
dns.Question[0] = Question{z, TypeSOA, ClassINET}
|
2011-09-02 22:28:40 +10:00
|
|
|
}
|
|
|
|
|
2011-09-11 00:50:27 +10:00
|
|
|
// SetIxfr creates dns msg suitable for requesting an ixfr.
|
2011-09-02 22:28:40 +10:00
|
|
|
func (dns *Msg) SetIxfr(z string, serial uint32) {
|
|
|
|
dns.MsgHdr.Id = Id()
|
|
|
|
dns.Question = make([]Question, 1)
|
|
|
|
dns.Ns = make([]RR, 1)
|
|
|
|
s := new(RR_SOA)
|
2011-12-14 18:42:53 +11:00
|
|
|
s.Hdr = RR_Header{z, TypeSOA, ClassINET, DefaultTtl, 0}
|
2011-09-02 22:28:40 +10:00
|
|
|
s.Serial = serial
|
|
|
|
|
|
|
|
dns.Question[0] = Question{z, TypeIXFR, ClassINET}
|
|
|
|
dns.Ns[0] = s
|
|
|
|
}
|
|
|
|
|
2011-09-11 21:01:18 +10:00
|
|
|
// SetAxfr creates dns msg suitable for requesting an axfr.
|
2011-09-02 22:28:40 +10:00
|
|
|
func (dns *Msg) SetAxfr(z string) {
|
|
|
|
dns.MsgHdr.Id = Id()
|
|
|
|
dns.Question = make([]Question, 1)
|
|
|
|
dns.Question[0] = Question{z, TypeAXFR, ClassINET}
|
|
|
|
}
|
|
|
|
|
2011-09-11 09:10:47 +10:00
|
|
|
// SetTsig appends a TSIG RR to the message.
|
2011-09-11 21:01:18 +10:00
|
|
|
// This is only a skeleton Tsig RR that is added as the last RR in the
|
2011-09-11 09:10:47 +10:00
|
|
|
// additional section. The caller should then call TsigGenerate,
|
2011-09-11 21:01:18 +10:00
|
|
|
// to generate the complete TSIG with the secret.
|
2011-09-02 22:28:40 +10:00
|
|
|
func (dns *Msg) SetTsig(z, algo string, fudge uint16, timesigned uint64) {
|
|
|
|
t := new(RR_TSIG)
|
|
|
|
t.Hdr = RR_Header{z, TypeTSIG, ClassANY, 0, 0}
|
|
|
|
t.Algorithm = algo
|
2011-09-11 09:10:47 +10:00
|
|
|
t.Fudge = 300
|
2011-09-02 22:28:40 +10:00
|
|
|
t.TimeSigned = timesigned
|
|
|
|
dns.Extra = append(dns.Extra, t)
|
|
|
|
}
|
|
|
|
|
2011-09-11 21:01:18 +10:00
|
|
|
// SetEdns0 appends a EDNS0 OPT RR to the message.
|
|
|
|
// TSIG should always the last RR in a message.
|
|
|
|
func (dns *Msg) SetEdns0(udpsize uint16, do bool) {
|
2011-11-28 16:03:21 +11:00
|
|
|
e := new(RR_OPT)
|
|
|
|
e.Hdr.Name = "."
|
|
|
|
e.Hdr.Rrtype = TypeOPT
|
|
|
|
e.SetUDPSize(udpsize)
|
|
|
|
if do {
|
|
|
|
e.SetDo()
|
|
|
|
}
|
2011-09-11 21:01:18 +10:00
|
|
|
dns.Extra = append(dns.Extra, e)
|
|
|
|
}
|
|
|
|
|
2011-09-02 22:28:40 +10:00
|
|
|
// IsRcode checks if the header of the packet has rcode set.
|
|
|
|
func (dns *Msg) IsRcode(rcode int) (ok bool) {
|
|
|
|
if len(dns.Question) == 0 {
|
|
|
|
return false
|
|
|
|
}
|
2011-11-28 16:03:21 +11:00
|
|
|
ok = dns.MsgHdr.Rcode == rcode
|
|
|
|
return
|
2011-09-02 22:28:40 +10:00
|
|
|
}
|
|
|
|
|
2011-09-11 21:01:18 +10:00
|
|
|
// IsQuestion returns true if the packet is a question.
|
2011-08-22 20:52:13 +10:00
|
|
|
func (dns *Msg) IsQuestion() (ok bool) {
|
2011-11-28 16:03:21 +11:00
|
|
|
if len(dns.Question) == 0 {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
ok = dns.MsgHdr.Response == false
|
|
|
|
return
|
2011-08-22 20:52:13 +10:00
|
|
|
}
|
|
|
|
|
2011-09-11 21:01:18 +10:00
|
|
|
// IsRcodeFormatError checks if the message has FormErr set.
|
2011-07-27 05:41:24 +10:00
|
|
|
func (dns *Msg) IsRcodeFormatError() (ok bool) {
|
|
|
|
if len(dns.Question) == 0 {
|
|
|
|
return false
|
|
|
|
}
|
2011-11-28 16:03:21 +11:00
|
|
|
ok = dns.MsgHdr.Rcode == RcodeFormatError
|
|
|
|
return
|
2011-07-27 05:41:24 +10:00
|
|
|
}
|
|
|
|
|
2011-09-02 22:28:40 +10:00
|
|
|
// IsUpdate checks if the message is a dynamic update packet.
|
2011-03-25 20:16:55 +11:00
|
|
|
func (dns *Msg) IsUpdate() (ok bool) {
|
|
|
|
if len(dns.Question) == 0 {
|
|
|
|
return false
|
|
|
|
}
|
2011-07-06 04:52:35 +10:00
|
|
|
ok = dns.MsgHdr.Opcode == OpcodeUpdate
|
|
|
|
ok = ok && dns.Question[0].Qtype == TypeSOA
|
|
|
|
return
|
2011-03-25 20:16:55 +11:00
|
|
|
}
|
|
|
|
|
2011-09-02 22:28:40 +10:00
|
|
|
// IsNotify checks if the message is a valid notify packet.
|
2011-03-23 19:50:38 +11:00
|
|
|
func (dns *Msg) IsNotify() (ok bool) {
|
2011-03-16 22:19:15 +11:00
|
|
|
if len(dns.Question) == 0 {
|
2011-03-23 19:50:38 +11:00
|
|
|
return false
|
2011-03-16 22:19:15 +11:00
|
|
|
}
|
2011-03-23 19:50:38 +11:00
|
|
|
ok = dns.MsgHdr.Opcode == OpcodeNotify
|
2011-03-16 22:19:15 +11:00
|
|
|
ok = ok && dns.Question[0].Qclass == ClassINET
|
|
|
|
ok = ok && dns.Question[0].Qtype == TypeSOA
|
2011-04-19 06:08:12 +10:00
|
|
|
return
|
2011-03-16 22:19:15 +11:00
|
|
|
}
|
|
|
|
|
2011-09-02 22:28:40 +10:00
|
|
|
// IsAxfr checks if the message is a valid axfr request packet.
|
2011-03-23 20:48:21 +11:00
|
|
|
func (dns *Msg) IsAxfr() (ok bool) {
|
|
|
|
if len(dns.Question) == 0 {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
ok = dns.MsgHdr.Opcode == OpcodeQuery
|
|
|
|
ok = ok && dns.Question[0].Qclass == ClassINET
|
|
|
|
ok = ok && dns.Question[0].Qtype == TypeAXFR
|
2011-04-19 06:08:12 +10:00
|
|
|
return
|
2011-03-23 20:48:21 +11:00
|
|
|
}
|
|
|
|
|
2011-09-02 22:28:40 +10:00
|
|
|
// IsIXfr checks if the message is a valid ixfr request packet.
|
2011-03-23 20:48:21 +11:00
|
|
|
func (dns *Msg) IsIxfr() (ok bool) {
|
|
|
|
if len(dns.Question) == 0 {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
ok = dns.MsgHdr.Opcode == OpcodeQuery
|
|
|
|
ok = ok && dns.Question[0].Qclass == ClassINET
|
|
|
|
ok = ok && dns.Question[0].Qtype == TypeIXFR
|
2011-04-19 06:08:12 +10:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2011-09-11 09:10:47 +10:00
|
|
|
// IsTsig checks if the message has a TSIG record as the last record
|
|
|
|
// in the additional section.
|
2011-04-19 06:08:12 +10:00
|
|
|
func (dns *Msg) IsTsig() (ok bool) {
|
2011-07-06 04:52:35 +10:00
|
|
|
if len(dns.Extra) > 0 {
|
2011-09-11 00:50:27 +10:00
|
|
|
return dns.Extra[len(dns.Extra)-1].Header().Rrtype == TypeTSIG
|
2011-07-06 04:52:35 +10:00
|
|
|
}
|
|
|
|
return
|
2011-04-19 06:08:12 +10:00
|
|
|
}
|
|
|
|
|
2011-09-19 21:34:16 +10:00
|
|
|
// IsEdns0 checks if the message has a Edns0 record, any EDNS0
|
2012-01-27 08:47:54 +11:00
|
|
|
// record in the additional section will do.
|
2011-09-11 21:01:18 +10:00
|
|
|
func (dns *Msg) IsEdns0() (ok bool) {
|
2011-11-28 16:03:21 +11:00
|
|
|
for _, r := range dns.Extra {
|
|
|
|
if r.Header().Rrtype == TypeOPT {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return
|
2011-09-11 21:01:18 +10:00
|
|
|
}
|
|
|
|
|
2012-01-09 00:06:58 +11:00
|
|
|
// IsDomainName checks if s is a valid domainname, it returns
|
2012-01-31 07:26:29 +11:00
|
|
|
// the number of labels, total length and true, when a domain name is valid.
|
|
|
|
// When false the returned labelcount and length is 0 and 0.
|
|
|
|
func IsDomainName(s string) (uint8, uint8, bool) { // copied from net package.
|
2011-07-25 01:08:33 +10:00
|
|
|
// See RFC 1035, RFC 3696.
|
2012-02-05 21:33:55 +11:00
|
|
|
l := len(s)
|
2012-01-31 07:26:29 +11:00
|
|
|
if l == 0 || l > 255 {
|
|
|
|
return 0, 0, false
|
2011-07-25 01:08:33 +10:00
|
|
|
}
|
2012-02-05 21:33:55 +11:00
|
|
|
longer := 0
|
|
|
|
// Simplify checking loop: make the name end in a dot.
|
|
|
|
// Don't call Fqdn() to save another len(s).
|
|
|
|
// Keep in mind that if we do this, we report a longer
|
|
|
|
// length
|
|
|
|
if s[l-1] != '.' {
|
|
|
|
s += "."
|
|
|
|
l++
|
|
|
|
longer = 1
|
|
|
|
}
|
2011-07-25 01:08:33 +10:00
|
|
|
last := byte('.')
|
|
|
|
ok := false // ok once we've seen a letter
|
|
|
|
partlen := 0
|
2012-01-09 01:56:19 +11:00
|
|
|
labels := uint8(0)
|
2012-01-31 07:26:29 +11:00
|
|
|
for i := 0; i < l; i++ {
|
2011-07-25 01:08:33 +10:00
|
|
|
c := s[i]
|
|
|
|
switch {
|
|
|
|
default:
|
2012-02-05 21:33:55 +11:00
|
|
|
return 0, uint8(l - longer), false
|
2011-07-25 06:21:48 +10:00
|
|
|
case 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || c == '_' || c == '*':
|
2011-07-25 01:08:33 +10:00
|
|
|
ok = true
|
|
|
|
partlen++
|
2012-01-09 01:54:33 +11:00
|
|
|
case c == '\\':
|
|
|
|
// Ok
|
2011-07-25 01:08:33 +10:00
|
|
|
case '0' <= c && c <= '9':
|
|
|
|
// fine
|
|
|
|
partlen++
|
|
|
|
case c == '-':
|
|
|
|
// byte before dash cannot be dot
|
|
|
|
if last == '.' {
|
2012-02-05 21:33:55 +11:00
|
|
|
return 0, uint8(l - longer), false
|
2011-07-25 01:08:33 +10:00
|
|
|
}
|
|
|
|
partlen++
|
|
|
|
case c == '.':
|
|
|
|
// byte before dot cannot be dot, dash
|
|
|
|
if last == '.' || last == '-' {
|
2012-02-05 21:33:55 +11:00
|
|
|
return 0, uint8(l - longer), false
|
2012-01-09 01:54:33 +11:00
|
|
|
}
|
|
|
|
if last == '\\' { // Ok, escaped dot.
|
|
|
|
partlen++
|
|
|
|
break
|
2011-07-25 01:08:33 +10:00
|
|
|
}
|
|
|
|
if partlen > 63 || partlen == 0 {
|
2012-02-05 21:33:55 +11:00
|
|
|
return 0, uint8(l - longer), false
|
2011-07-25 01:08:33 +10:00
|
|
|
}
|
|
|
|
partlen = 0
|
2012-01-09 01:54:33 +11:00
|
|
|
labels++
|
2011-07-25 01:08:33 +10:00
|
|
|
}
|
|
|
|
last = c
|
|
|
|
}
|
2012-02-05 21:33:55 +11:00
|
|
|
return labels, uint8(l - longer), ok
|
2011-07-25 01:08:33 +10:00
|
|
|
}
|
|
|
|
|
2012-01-09 01:54:33 +11:00
|
|
|
// IsFqdn checks if a domain name is fully qualified
|
|
|
|
func IsFqdn(s string) bool {
|
|
|
|
if len(s) == 0 {
|
|
|
|
return false // ?
|
2011-07-25 01:08:33 +10:00
|
|
|
}
|
2012-01-09 01:54:33 +11:00
|
|
|
return s[len(s)-1] == '.'
|
|
|
|
}
|
|
|
|
|
|
|
|
// Fqdns return the fully qualified domain name from s.
|
|
|
|
// Is s is already fq, then it behaves as the identity function.
|
|
|
|
func Fqdn(s string) string {
|
|
|
|
if IsFqdn(s) {
|
|
|
|
return s
|
|
|
|
}
|
|
|
|
return s + "."
|
2011-07-25 01:08:33 +10:00
|
|
|
}
|