1package dns
2
3import (
4	"fmt"
5	"time"
6)
7
8// Envelope is used when doing a zone transfer with a remote server.
9type Envelope struct {
10	RR    []RR  // The set of RRs in the answer section of the xfr reply message.
11	Error error // If something went wrong, this contains the error.
12}
13
14// A Transfer defines parameters that are used during a zone transfer.
15type Transfer struct {
16	*Conn
17	DialTimeout    time.Duration     // net.DialTimeout, defaults to 2 seconds
18	ReadTimeout    time.Duration     // net.Conn.SetReadTimeout value for connections, defaults to 2 seconds
19	WriteTimeout   time.Duration     // net.Conn.SetWriteTimeout value for connections, defaults to 2 seconds
20	TsigSecret     map[string]string // Secret(s) for Tsig map[<zonename>]<base64 secret>, zonename must be in canonical form (lowercase, fqdn, see RFC 4034 Section 6.2)
21	tsigTimersOnly bool
22}
23
24// Think we need to away to stop the transfer
25
26// In performs an incoming transfer with the server in a.
27// If you would like to set the source IP, or some other attribute
28// of a Dialer for a Transfer, you can do so by specifying the attributes
29// in the Transfer.Conn:
30//
31//	d := net.Dialer{LocalAddr: transfer_source}
32//	con, err := d.Dial("tcp", master)
33//	dnscon := &dns.Conn{Conn:con}
34//	transfer = &dns.Transfer{Conn: dnscon}
35//	channel, err := transfer.In(message, master)
36//
37func (t *Transfer) In(q *Msg, a string) (env chan *Envelope, err error) {
38	switch q.Question[0].Qtype {
39	case TypeAXFR, TypeIXFR:
40	default:
41		return nil, &Error{"unsupported question type"}
42	}
43
44	timeout := dnsTimeout
45	if t.DialTimeout != 0 {
46		timeout = t.DialTimeout
47	}
48
49	if t.Conn == nil {
50		t.Conn, err = DialTimeout("tcp", a, timeout)
51		if err != nil {
52			return nil, err
53		}
54	}
55
56	if err := t.WriteMsg(q); err != nil {
57		return nil, err
58	}
59
60	env = make(chan *Envelope)
61	switch q.Question[0].Qtype {
62	case TypeAXFR:
63		go t.inAxfr(q, env)
64	case TypeIXFR:
65		go t.inIxfr(q, env)
66	}
67
68	return env, nil
69}
70
71func (t *Transfer) inAxfr(q *Msg, c chan *Envelope) {
72	first := true
73	defer t.Close()
74	defer close(c)
75	timeout := dnsTimeout
76	if t.ReadTimeout != 0 {
77		timeout = t.ReadTimeout
78	}
79	for {
80		t.Conn.SetReadDeadline(time.Now().Add(timeout))
81		in, err := t.ReadMsg()
82		if err != nil {
83			c <- &Envelope{nil, err}
84			return
85		}
86		if q.Id != in.Id {
87			c <- &Envelope{in.Answer, ErrId}
88			return
89		}
90		if first {
91			if in.Rcode != RcodeSuccess {
92				c <- &Envelope{in.Answer, &Error{err: fmt.Sprintf(errXFR, in.Rcode)}}
93				return
94			}
95			if !isSOAFirst(in) {
96				c <- &Envelope{in.Answer, ErrSoa}
97				return
98			}
99			first = !first
100			// only one answer that is SOA, receive more
101			if len(in.Answer) == 1 {
102				t.tsigTimersOnly = true
103				c <- &Envelope{in.Answer, nil}
104				continue
105			}
106		}
107
108		if !first {
109			t.tsigTimersOnly = true // Subsequent envelopes use this.
110			if isSOALast(in) {
111				c <- &Envelope{in.Answer, nil}
112				return
113			}
114			c <- &Envelope{in.Answer, nil}
115		}
116	}
117}
118
119func (t *Transfer) inIxfr(q *Msg, c chan *Envelope) {
120	var serial uint32 // The first serial seen is the current server serial
121	axfr := true
122	n := 0
123	qser := q.Ns[0].(*SOA).Serial
124	defer t.Close()
125	defer close(c)
126	timeout := dnsTimeout
127	if t.ReadTimeout != 0 {
128		timeout = t.ReadTimeout
129	}
130	for {
131		t.SetReadDeadline(time.Now().Add(timeout))
132		in, err := t.ReadMsg()
133		if err != nil {
134			c <- &Envelope{nil, err}
135			return
136		}
137		if q.Id != in.Id {
138			c <- &Envelope{in.Answer, ErrId}
139			return
140		}
141		if in.Rcode != RcodeSuccess {
142			c <- &Envelope{in.Answer, &Error{err: fmt.Sprintf(errXFR, in.Rcode)}}
143			return
144		}
145		if n == 0 {
146			// Check if the returned answer is ok
147			if !isSOAFirst(in) {
148				c <- &Envelope{in.Answer, ErrSoa}
149				return
150			}
151			// This serial is important
152			serial = in.Answer[0].(*SOA).Serial
153			// Check if there are no changes in zone
154			if qser >= serial {
155				c <- &Envelope{in.Answer, nil}
156				return
157			}
158		}
159		// Now we need to check each message for SOA records, to see what we need to do
160		t.tsigTimersOnly = true
161		for _, rr := range in.Answer {
162			if v, ok := rr.(*SOA); ok {
163				if v.Serial == serial {
164					n++
165					// quit if it's a full axfr or the the servers' SOA is repeated the third time
166					if axfr && n == 2 || n == 3 {
167						c <- &Envelope{in.Answer, nil}
168						return
169					}
170				} else if axfr {
171					// it's an ixfr
172					axfr = false
173				}
174			}
175		}
176		c <- &Envelope{in.Answer, nil}
177	}
178}
179
180// Out performs an outgoing transfer with the client connecting in w.
181// Basic use pattern:
182//
183//	ch := make(chan *dns.Envelope)
184//	tr := new(dns.Transfer)
185//	var wg sync.WaitGroup
186//	go func() {
187//		tr.Out(w, r, ch)
188//		wg.Done()
189//	}()
190//	ch <- &dns.Envelope{RR: []dns.RR{soa, rr1, rr2, rr3, soa}}
191//	close(ch)
192//	wg.Wait() // wait until everything is written out
193//	w.Close() // close connection
194//
195// The server is responsible for sending the correct sequence of RRs through the channel ch.
196func (t *Transfer) Out(w ResponseWriter, q *Msg, ch chan *Envelope) error {
197	for x := range ch {
198		r := new(Msg)
199		// Compress?
200		r.SetReply(q)
201		r.Authoritative = true
202		// assume it fits TODO(miek): fix
203		r.Answer = append(r.Answer, x.RR...)
204		if tsig := q.IsTsig(); tsig != nil && w.TsigStatus() == nil {
205			r.SetTsig(tsig.Hdr.Name, tsig.Algorithm, tsig.Fudge, time.Now().Unix())
206		}
207		if err := w.WriteMsg(r); err != nil {
208			return err
209		}
210		w.TsigTimersOnly(true)
211	}
212	return nil
213}
214
215// ReadMsg reads a message from the transfer connection t.
216func (t *Transfer) ReadMsg() (*Msg, error) {
217	m := new(Msg)
218	p := make([]byte, MaxMsgSize)
219	n, err := t.Read(p)
220	if err != nil && n == 0 {
221		return nil, err
222	}
223	p = p[:n]
224	if err := m.Unpack(p); err != nil {
225		return nil, err
226	}
227	if ts := m.IsTsig(); ts != nil && t.TsigSecret != nil {
228		if _, ok := t.TsigSecret[ts.Hdr.Name]; !ok {
229			return m, ErrSecret
230		}
231		// Need to work on the original message p, as that was used to calculate the tsig.
232		err = TsigVerify(p, t.TsigSecret[ts.Hdr.Name], t.tsigRequestMAC, t.tsigTimersOnly)
233		t.tsigRequestMAC = ts.MAC
234	}
235	return m, err
236}
237
238// WriteMsg writes a message through the transfer connection t.
239func (t *Transfer) WriteMsg(m *Msg) (err error) {
240	var out []byte
241	if ts := m.IsTsig(); ts != nil && t.TsigSecret != nil {
242		if _, ok := t.TsigSecret[ts.Hdr.Name]; !ok {
243			return ErrSecret
244		}
245		out, t.tsigRequestMAC, err = TsigGenerate(m, t.TsigSecret[ts.Hdr.Name], t.tsigRequestMAC, t.tsigTimersOnly)
246	} else {
247		out, err = m.Pack()
248	}
249	if err != nil {
250		return err
251	}
252	_, err = t.Write(out)
253	return err
254}
255
256func isSOAFirst(in *Msg) bool {
257	return len(in.Answer) > 0 &&
258		in.Answer[0].Header().Rrtype == TypeSOA
259}
260
261func isSOALast(in *Msg) bool {
262	return len(in.Answer) > 0 &&
263		in.Answer[len(in.Answer)-1].Header().Rrtype == TypeSOA
264}
265
266const errXFR = "bad xfr rcode: %d"
267