252 lines
5.8 KiB
Go
252 lines
5.8 KiB
Go
package dns
|
|
|
|
import (
|
|
"os"
|
|
)
|
|
|
|
// Xfr is used in communicating with Xfr* functions.
|
|
type Xfr struct {
|
|
// If Add is true the resource record in RR must be added to
|
|
// the zone. If Add is false the resource record must be removed.
|
|
// be considered to have failed.
|
|
Add bool
|
|
// The RR that should be added or removed.
|
|
RR
|
|
// If err in non nil some error occurred and the transfer must
|
|
// be considered to have faild.
|
|
Err os.Error
|
|
}
|
|
// todo maybe add the SOA serial too?
|
|
|
|
// Perform an incoming Ixfr or Axfr. If the message q's question
|
|
// section contains an AXFR type an Axfr is performed. If q's question
|
|
// section contains an IXFR type an Ixfr is performed.
|
|
func (d *Conn) XfrRead(q *Msg, m chan *Xfr) {
|
|
if d.TCP == nil && d.UDP == nil {
|
|
// No connection yet
|
|
if err := d.Dial("tcp"); err != nil {
|
|
m <- &Xfr{true, nil, err}
|
|
close(m)
|
|
return
|
|
}
|
|
}
|
|
// Send q now.
|
|
err := d.WriteMsg(q)
|
|
if err != nil {
|
|
m <- &Xfr{true, nil, err}
|
|
close(m)
|
|
return
|
|
}
|
|
switch q.Question[0].Qtype {
|
|
case TypeAXFR:
|
|
d.axfrRead(q, m)
|
|
case TypeIXFR:
|
|
d.ixfrRead(q, m)
|
|
default:
|
|
m <- &Xfr{true, nil, &Error{Error: "Xfr Qtype not recognized"}}
|
|
close(m)
|
|
}
|
|
}
|
|
|
|
// Perform an outgoing Ixfr or Axfr. If the message q's question
|
|
// section contains an AXFR type an Axfr is performed. If q's question
|
|
// section contains an IXFR type an Ixfr is performed.
|
|
// The actual records to send are given on the channel m. And errors
|
|
// during transport are return on channel e.
|
|
func (d *Conn) XfrWrite(q *Msg, m chan *Xfr, e chan os.Error) {
|
|
switch q.Question[0].Qtype {
|
|
case TypeAXFR:
|
|
d.axfrWrite(q, m, e)
|
|
case TypeIXFR:
|
|
// d.ixfrWrite(q, m)
|
|
default:
|
|
e <- &Error{Error: "Xfr Qtype not recognized"}
|
|
close(m)
|
|
}
|
|
}
|
|
|
|
func (d *Conn) axfrRead(q *Msg, m chan *Xfr) {
|
|
defer close(m)
|
|
first := true
|
|
in := new(Msg)
|
|
for {
|
|
err := d.ReadMsg(in)
|
|
if err != nil {
|
|
m <- &Xfr{true, nil, err}
|
|
return
|
|
}
|
|
if in.Id != q.Id {
|
|
m <- &Xfr{true, nil, ErrId}
|
|
return
|
|
}
|
|
|
|
if first {
|
|
if !checkXfrSOA(in, true) {
|
|
m <- &Xfr{true, nil, ErrXfrSoa}
|
|
return
|
|
}
|
|
first = !first
|
|
}
|
|
|
|
if !first {
|
|
if d.Tsig != nil {
|
|
d.Tsig.TimersOnly = true // Subsequent envelopes use this.
|
|
}
|
|
if !checkXfrSOA(in, false) {
|
|
// Soa record not the last one
|
|
sendMsg(in, m, false)
|
|
continue
|
|
} else {
|
|
sendMsg(in, m, true)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
panic("not reached")
|
|
return
|
|
}
|
|
|
|
// Just send the zone
|
|
func (d *Conn) axfrWrite(q *Msg, m chan *Xfr, e chan os.Error) {
|
|
out := new(Msg)
|
|
out.Id = q.Id
|
|
out.Question = q.Question
|
|
out.Answer = make([]RR, 1001) // TODO(mg) look at this number
|
|
out.MsgHdr.Response = true
|
|
out.MsgHdr.Authoritative = true
|
|
first := true
|
|
var soa *RR_SOA
|
|
i := 0
|
|
for r := range m {
|
|
out.Answer[i] = r.RR
|
|
if soa == nil {
|
|
if r.RR.Header().Rrtype != TypeSOA {
|
|
e <- ErrXfrSoa
|
|
return
|
|
} else {
|
|
soa = r.RR.(*RR_SOA)
|
|
}
|
|
}
|
|
i++
|
|
if i > 1000 {
|
|
// Send it
|
|
err := d.WriteMsg(out)
|
|
if err != nil {
|
|
e <- err
|
|
return
|
|
}
|
|
i = 0
|
|
// Gaat dit goed?
|
|
out.Answer = out.Answer[:0]
|
|
if first {
|
|
if d.Tsig != nil {
|
|
d.Tsig.TimersOnly = true
|
|
}
|
|
first = !first
|
|
}
|
|
}
|
|
}
|
|
// Everything is sent, only the closing soa is left.
|
|
out.Answer[i] = soa
|
|
out.Answer = out.Answer[:i+1]
|
|
err := d.WriteMsg(out)
|
|
if err != nil {
|
|
e <- err
|
|
}
|
|
}
|
|
|
|
func (d *Conn) ixfrRead(q *Msg, m chan *Xfr) {
|
|
defer close(m)
|
|
var serial uint32 // The first serial seen is the current server serial
|
|
var x *Xfr
|
|
first := true
|
|
in := new(Msg)
|
|
for {
|
|
|
|
err := d.ReadMsg(in)
|
|
if err != nil {
|
|
m <- &Xfr{true, nil, err}
|
|
return
|
|
}
|
|
if in.Id != q.Id {
|
|
m <- &Xfr{true, nil, ErrId}
|
|
return
|
|
}
|
|
|
|
if first {
|
|
// A single SOA RR signals "no changes"
|
|
if len(in.Answer) == 1 && checkXfrSOA(in, true) {
|
|
return
|
|
}
|
|
|
|
// But still check if the returned answer is ok
|
|
if !checkXfrSOA(in, true) {
|
|
m <- &Xfr{true, nil, ErrXfrSoa}
|
|
return
|
|
}
|
|
// This serial is important
|
|
serial = in.Answer[0].(*RR_SOA).Serial
|
|
first = !first
|
|
}
|
|
|
|
// Now we need to check each message for SOA records, to see what we need to do
|
|
x.Add = true
|
|
if !first {
|
|
if d.Tsig != nil {
|
|
d.Tsig.TimersOnly = true
|
|
}
|
|
for k, r := range in.Answer {
|
|
// If the last record in the IXFR contains the servers' SOA, we should quit
|
|
if r.Header().Rrtype == TypeSOA {
|
|
switch {
|
|
case r.(*RR_SOA).Serial == serial:
|
|
if k == len(in.Answer)-1 {
|
|
// last rr is SOA with correct serial
|
|
//m <- r dont' send it
|
|
return
|
|
}
|
|
x.Add = true
|
|
if k != 0 {
|
|
// Intermediate SOA
|
|
continue
|
|
}
|
|
case r.(*RR_SOA).Serial != serial:
|
|
x.Add = false
|
|
continue // Don't need to see this SOA
|
|
}
|
|
}
|
|
x.RR = r
|
|
m <- x
|
|
}
|
|
}
|
|
}
|
|
panic("not reached")
|
|
return
|
|
}
|
|
|
|
// Check if he SOA record exists in the Answer section of
|
|
// the packet. If first is true the first RR must be a soa
|
|
// if false, the last one should be a SOA
|
|
func checkXfrSOA(in *Msg, first bool) bool {
|
|
if len(in.Answer) > 0 {
|
|
if first {
|
|
return in.Answer[0].Header().Rrtype == TypeSOA
|
|
} else {
|
|
return in.Answer[len(in.Answer)-1].Header().Rrtype == TypeSOA
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Send the answer section to the channel
|
|
func sendMsg(in *Msg, c chan *Xfr, nosoa bool) {
|
|
for k, r := range in.Answer {
|
|
x := &Xfr{Add: true}
|
|
if nosoa && k == len(in.Answer)-1 {
|
|
continue
|
|
}
|
|
x.RR = r
|
|
c <- x
|
|
}
|
|
}
|