2013-05-13 00:15:52 +10:00
|
|
|
// Copyright 2011 Miek Gieben. All rights reserved.
|
|
|
|
// Use of this source code is governed by a BSD-style
|
|
|
|
// license that can be found in the LICENSE file.
|
|
|
|
|
2011-03-17 02:21:35 +11:00
|
|
|
package dns
|
|
|
|
|
2013-10-03 05:35:13 +10:00
|
|
|
import (
|
|
|
|
"net"
|
|
|
|
"time"
|
|
|
|
)
|
|
|
|
|
2013-10-11 06:01:35 +11:00
|
|
|
// Envelope is used when doing a transfer with a remote server.
|
2012-12-02 18:47:32 +11:00
|
|
|
type Envelope struct {
|
2012-12-02 18:41:49 +11:00
|
|
|
RR []RR // The set of RRs in the answer section of the AXFR reply message.
|
|
|
|
Error error // If something went wrong, this contains the error.
|
2012-08-08 17:44:34 +10:00
|
|
|
}
|
|
|
|
|
2013-10-03 05:35:13 +10:00
|
|
|
type Transfer struct {
|
|
|
|
Conn
|
2013-10-11 06:01:35 +11:00
|
|
|
DialTimeout time.Duration // net.DialTimeout (ns), defaults to 2 * 1e9
|
|
|
|
ReadTimeout time.Duration // net.Conn.SetReadTimeout value for connections (ns), defaults to 2 * 1e9
|
|
|
|
WriteTimeout time.Duration // net.Conn.SetWriteTimeout value for connections (ns), defaults to 2 * 1e9
|
2013-10-12 03:18:37 +11:00
|
|
|
tsigTimersOnly bool
|
2013-10-03 05:35:13 +10:00
|
|
|
}
|
|
|
|
|
|
|
|
// In performs a [AI]XFR request (depends on the message's Qtype). It returns
|
|
|
|
// a channel of *Envelope on which the replies from the server are sent.
|
|
|
|
// At the end of the transfer the channel is closed.
|
|
|
|
// The messages are TSIG checked if needed, no other post-processing is performed.
|
|
|
|
// The caller must dissect the returned messages.
|
2012-08-28 03:48:58 +10:00
|
|
|
//
|
|
|
|
// Basic use pattern for receiving an AXFR:
|
|
|
|
//
|
2012-08-28 04:58:58 +10:00
|
|
|
// // m contains the AXFR request
|
2013-10-03 05:35:13 +10:00
|
|
|
// t := new(dns.Transfer)
|
|
|
|
// c, e := t.In(m, "127.0.0.1:53")
|
|
|
|
// for env := range c
|
|
|
|
// // ... deal with env.RR or env.Error
|
2012-08-28 03:48:58 +10:00
|
|
|
// }
|
2013-10-03 05:35:13 +10:00
|
|
|
|
|
|
|
func (t *Transfer) In(q *Msg, a string, env chan *Envelope) (err error) {
|
|
|
|
co := new(Conn)
|
|
|
|
timeout := dnsTimeout
|
|
|
|
if t.DialTimeout != 0 {
|
|
|
|
timeout = t.DialTimeout
|
|
|
|
}
|
|
|
|
co.Conn, err = net.DialTimeout("tcp", a, timeout)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2013-10-11 06:01:35 +11:00
|
|
|
if q.Question[0].Qtype == TypeAXFR {
|
|
|
|
go t.InAxfr(q.Id, env)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
if q.Question[0].Qtype == TypeIXFR {
|
|
|
|
go t.InAxfr(q.Id, env)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return nil // TODO(miek): some error
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Transfer) InAxfr(id uint16, c chan *Envelope) {
|
|
|
|
first := true
|
|
|
|
defer t.Close()
|
|
|
|
defer close(c)
|
|
|
|
for {
|
|
|
|
in, err := t.ReadMsg()
|
|
|
|
if err != nil {
|
|
|
|
c <- &Envelope{nil, err}
|
|
|
|
return
|
|
|
|
}
|
2013-10-12 03:18:37 +11:00
|
|
|
if id != in.Id {
|
2013-10-11 06:01:35 +11:00
|
|
|
c <- &Envelope{in.Answer, ErrId}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if first {
|
2013-10-12 03:18:37 +11:00
|
|
|
if !isSOAFirst(in) {
|
2013-10-11 06:01:35 +11:00
|
|
|
c <- &Envelope{in.Answer, ErrSoa}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
first = !first
|
|
|
|
// only one answer that is SOA, receive more
|
|
|
|
if len(in.Answer) == 1 {
|
2013-10-12 03:18:37 +11:00
|
|
|
t.tsigTimersOnly = true
|
2013-10-11 06:01:35 +11:00
|
|
|
c <- &Envelope{in.Answer, nil}
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if !first {
|
2013-10-12 03:18:37 +11:00
|
|
|
t.tsigTimersOnly = true // Subsequent envelopes use this.
|
|
|
|
if isSOALast(in) {
|
2013-10-11 06:01:35 +11:00
|
|
|
c <- &Envelope{in.Answer, nil}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
c <- &Envelope{in.Answer, nil}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
panic("dns: not reached")
|
|
|
|
}
|
|
|
|
|
2013-10-12 03:18:37 +11:00
|
|
|
/*
|
2013-10-03 05:35:13 +10:00
|
|
|
// re-read 'n stuff must be pushed down
|
|
|
|
timeout = dnsTimeout
|
|
|
|
if t.ReadTimeout != 0 {
|
|
|
|
timeout = t.ReadTimeout
|
|
|
|
}
|
|
|
|
co.SetReadDeadline(time.Now().Add(dnsTimeout))
|
|
|
|
timeout = dnsTimeout
|
|
|
|
if t.WriteTimeout != 0 {
|
|
|
|
timeout = t.WriteTimeout
|
|
|
|
}
|
|
|
|
co.SetWriteDeadline(time.Now().Add(dnsTimeout))
|
|
|
|
defer co.Close()
|
|
|
|
return nil
|
2013-10-12 03:18:37 +11:00
|
|
|
*/
|
2013-10-03 05:35:13 +10:00
|
|
|
|
2013-10-11 06:01:35 +11:00
|
|
|
func (t *Transfer) Out(w ResponseWriter, q *Msg, a string) (chan *Envelope, error) {
|
|
|
|
ch := make(chan *Envelope)
|
2013-10-12 03:18:37 +11:00
|
|
|
r := new(Msg)
|
|
|
|
r.SetReply(q)
|
|
|
|
r.Authoritative = true
|
|
|
|
go func() {
|
|
|
|
for x := range ch {
|
|
|
|
// assume it fits TODO(miek): fix
|
|
|
|
r.Answer = append(r.Answer, x.RR...)
|
|
|
|
if err := w.WriteMsg(r); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// w.TsigTimersOnly(true)
|
|
|
|
// rep.Answer = nil
|
|
|
|
}()
|
2013-10-11 06:01:35 +11:00
|
|
|
return ch, nil
|
2013-10-03 05:35:13 +10:00
|
|
|
}
|
|
|
|
|
|
|
|
// ReadMsg reads a message from the transfer connection t.
|
|
|
|
func (t *Transfer) ReadMsg() (*Msg, error) {
|
|
|
|
m := new(Msg)
|
|
|
|
p := make([]byte, MaxMsgSize)
|
2013-10-11 06:01:35 +11:00
|
|
|
n, err := t.Read(p)
|
2013-10-03 05:35:13 +10:00
|
|
|
if err != nil && n == 0 {
|
2012-05-18 20:06:31 +10:00
|
|
|
return nil, err
|
2011-09-12 06:10:04 +10:00
|
|
|
}
|
2013-10-03 05:35:13 +10:00
|
|
|
p = p[:n]
|
|
|
|
if err := m.Unpack(p); err != nil {
|
2012-05-18 20:06:31 +10:00
|
|
|
return nil, err
|
2011-04-19 06:08:12 +10:00
|
|
|
}
|
2013-10-03 05:35:13 +10:00
|
|
|
if ts := m.IsTsig(); t != nil {
|
|
|
|
if _, ok := t.TsigSecret[ts.Hdr.Name]; !ok {
|
|
|
|
return m, ErrSecret
|
|
|
|
}
|
|
|
|
// Need to work on the original message p, as that was used to calculate the tsig.
|
2013-10-12 03:18:37 +11:00
|
|
|
err = TsigVerify(p, t.TsigSecret[ts.Hdr.Name], t.tsigRequestMAC, t.tsigTimersOnly)
|
2013-10-03 05:35:13 +10:00
|
|
|
}
|
|
|
|
return m, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// WriteMsg write a message throught the transfer connection t.
|
|
|
|
func (t *Transfer) WriteMsg(m *Msg) (err error) {
|
|
|
|
var out []byte
|
|
|
|
if ts := m.IsTsig(); t != nil {
|
|
|
|
if _, ok := t.TsigSecret[ts.Hdr.Name]; !ok {
|
|
|
|
return ErrSecret
|
|
|
|
}
|
2013-10-12 03:18:37 +11:00
|
|
|
out, t.tsigRequestMAC, err = TsigGenerate(m, t.TsigSecret[ts.Hdr.Name], t.tsigRequestMAC, t.tsigTimersOnly)
|
2013-10-03 05:35:13 +10:00
|
|
|
} else {
|
|
|
|
out, err = m.Pack()
|
|
|
|
}
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2013-10-11 06:01:35 +11:00
|
|
|
if _, err = t.Write(out); err != nil {
|
2013-10-03 05:35:13 +10:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2011-04-18 17:58:15 +10:00
|
|
|
|
2012-12-02 19:01:23 +11:00
|
|
|
func (w *reply) ixfrIn(q *Msg, c chan *Envelope) {
|
2011-03-22 01:44:51 +11:00
|
|
|
var serial uint32 // The first serial seen is the current server serial
|
|
|
|
first := true
|
2012-08-23 18:33:33 +10:00
|
|
|
defer w.conn.Close()
|
2012-05-18 20:06:31 +10:00
|
|
|
defer close(c)
|
2011-03-22 01:44:51 +11:00
|
|
|
for {
|
2012-08-07 04:34:09 +10:00
|
|
|
in, err := w.receive()
|
2011-09-12 06:10:04 +10:00
|
|
|
if err != nil {
|
2012-12-02 18:47:32 +11:00
|
|
|
c <- &Envelope{in.Answer, err}
|
2011-09-12 06:10:04 +10:00
|
|
|
return
|
|
|
|
}
|
2012-08-31 23:03:25 +10:00
|
|
|
if q.Id != in.Id {
|
2012-12-02 18:47:32 +11:00
|
|
|
c <- &Envelope{in.Answer, ErrId}
|
2011-03-22 01:44:51 +11:00
|
|
|
return
|
|
|
|
}
|
|
|
|
if first {
|
|
|
|
// A single SOA RR signals "no changes"
|
2013-10-03 05:35:13 +10:00
|
|
|
if len(in.Answer) == 1 && checkSOA(in, true) {
|
2012-12-02 18:47:32 +11:00
|
|
|
c <- &Envelope{in.Answer, nil}
|
2011-09-12 06:10:04 +10:00
|
|
|
return
|
2011-03-22 01:44:51 +11:00
|
|
|
}
|
|
|
|
|
2011-09-11 00:49:22 +10:00
|
|
|
// Check if the returned answer is ok
|
2013-10-03 05:35:13 +10:00
|
|
|
if !checkSOA(in, true) {
|
2012-12-02 18:47:32 +11:00
|
|
|
c <- &Envelope{in.Answer, ErrSoa}
|
2011-03-22 01:44:51 +11:00
|
|
|
return
|
|
|
|
}
|
|
|
|
// This serial is important
|
2012-12-10 05:23:25 +11:00
|
|
|
serial = in.Answer[0].(*SOA).Serial
|
2011-03-22 01:44:51 +11:00
|
|
|
first = !first
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now we need to check each message for SOA records, to see what we need to do
|
|
|
|
if !first {
|
2011-09-12 06:10:04 +10:00
|
|
|
w.tsigTimersOnly = true
|
|
|
|
// If the last record in the IXFR contains the servers' SOA, we should quit
|
2012-12-10 05:23:25 +11:00
|
|
|
if v, ok := in.Answer[len(in.Answer)-1].(*SOA); ok {
|
2011-09-12 06:10:04 +10:00
|
|
|
if v.Serial == serial {
|
2012-12-02 18:47:32 +11:00
|
|
|
c <- &Envelope{in.Answer, nil}
|
2011-09-12 06:10:04 +10:00
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
2012-12-02 18:47:32 +11:00
|
|
|
c <- &Envelope{in.Answer, nil}
|
2011-03-22 01:44:51 +11:00
|
|
|
}
|
|
|
|
}
|
2012-08-29 02:21:23 +10:00
|
|
|
panic("dns: not reached")
|
2011-03-19 00:13:42 +11:00
|
|
|
}
|
2013-10-12 03:18:37 +11:00
|
|
|
*/
|
2011-09-12 01:24:52 +10:00
|
|
|
|
2013-10-12 03:18:37 +11:00
|
|
|
func isSOAFirst(in *Msg) bool {
|
2011-03-22 02:28:13 +11:00
|
|
|
if len(in.Answer) > 0 {
|
2013-10-11 06:01:35 +11:00
|
|
|
return in.Answer[0].Header().Rrtype == TypeSOA
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2013-10-12 03:18:37 +11:00
|
|
|
func isSOALast(in *Msg) bool {
|
2013-10-11 06:01:35 +11:00
|
|
|
if len(in.Answer) > 0 {
|
|
|
|
return in.Answer[len(in.Answer)-1].Header().Rrtype == TypeSOA
|
2011-03-22 02:28:13 +11:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|